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         c[D_GHASH][i] = c[D_GHASH][0] * 4 * l0 / l1;
1075
1076         l0 = (long)lengths[i - 1];
1077
1078         c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1079         c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1080         c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1081         c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1082         c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1083         c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1084         c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1085         c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1086         c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1087         c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1088         c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1089         c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1090         c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1091         c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1092         c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1093         c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1094         c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1095         c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1096     }
1097
1098 #  ifndef OPENSSL_NO_RSA
1099     rsa_c[R_RSA_512][0] = count / 2000;
1100     rsa_c[R_RSA_512][1] = count / 400;
1101     for (i = 1; i < RSA_NUM; i++) {
1102         rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1103         rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1104         if ((rsa_doit[i] <= 1) && (rsa_c[i][0] == 0))
1105             rsa_doit[i] = 0;
1106         else {
1107             if (rsa_c[i][0] == 0) {
1108                 rsa_c[i][0] = 1;
1109                 rsa_c[i][1] = 20;
1110             }
1111         }
1112     }
1113 #  endif
1114
1115 #  ifndef OPENSSL_NO_DSA
1116     dsa_c[R_DSA_512][0] = count / 1000;
1117     dsa_c[R_DSA_512][1] = count / 1000 / 2;
1118     for (i = 1; i < DSA_NUM; i++) {
1119         dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1120         dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1121         if ((dsa_doit[i] <= 1) && (dsa_c[i][0] == 0))
1122             dsa_doit[i] = 0;
1123         else {
1124             if (dsa_c[i] == 0) {
1125                 dsa_c[i][0] = 1;
1126                 dsa_c[i][1] = 1;
1127             }
1128         }
1129     }
1130 #  endif
1131
1132 #  ifndef OPENSSL_NO_EC
1133     ecdsa_c[R_EC_P160][0] = count / 1000;
1134     ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1135     for (i = R_EC_P192; i <= R_EC_P521; i++) {
1136         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1137         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1138         if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1139             ecdsa_doit[i] = 0;
1140         else {
1141             if (ecdsa_c[i] == 0) {
1142                 ecdsa_c[i][0] = 1;
1143                 ecdsa_c[i][1] = 1;
1144             }
1145         }
1146     }
1147     ecdsa_c[R_EC_K163][0] = count / 1000;
1148     ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1149     for (i = R_EC_K233; i <= R_EC_K571; i++) {
1150         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1151         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1152         if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1153             ecdsa_doit[i] = 0;
1154         else {
1155             if (ecdsa_c[i] == 0) {
1156                 ecdsa_c[i][0] = 1;
1157                 ecdsa_c[i][1] = 1;
1158             }
1159         }
1160     }
1161     ecdsa_c[R_EC_B163][0] = count / 1000;
1162     ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1163     for (i = R_EC_B233; i <= R_EC_B571; i++) {
1164         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1165         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1166         if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1167             ecdsa_doit[i] = 0;
1168         else {
1169             if (ecdsa_c[i] == 0) {
1170                 ecdsa_c[i][0] = 1;
1171                 ecdsa_c[i][1] = 1;
1172             }
1173         }
1174     }
1175
1176     ecdh_c[R_EC_P160][0] = count / 1000;
1177     ecdh_c[R_EC_P160][1] = count / 1000;
1178     for (i = R_EC_P192; i <= R_EC_P521; i++) {
1179         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1180         ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1181         if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1182             ecdh_doit[i] = 0;
1183         else {
1184             if (ecdh_c[i] == 0) {
1185                 ecdh_c[i][0] = 1;
1186                 ecdh_c[i][1] = 1;
1187             }
1188         }
1189     }
1190     ecdh_c[R_EC_K163][0] = count / 1000;
1191     ecdh_c[R_EC_K163][1] = count / 1000;
1192     for (i = R_EC_K233; i <= R_EC_K571; i++) {
1193         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1194         ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1195         if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1196             ecdh_doit[i] = 0;
1197         else {
1198             if (ecdh_c[i] == 0) {
1199                 ecdh_c[i][0] = 1;
1200                 ecdh_c[i][1] = 1;
1201             }
1202         }
1203     }
1204     ecdh_c[R_EC_B163][0] = count / 1000;
1205     ecdh_c[R_EC_B163][1] = count / 1000;
1206     for (i = R_EC_B233; i <= R_EC_B571; i++) {
1207         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1208         ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1209         if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1210             ecdh_doit[i] = 0;
1211         else {
1212             if (ecdh_c[i] == 0) {
1213                 ecdh_c[i][0] = 1;
1214                 ecdh_c[i][1] = 1;
1215             }
1216         }
1217     }
1218 #  endif
1219
1220 #  define COND(d) (count < (d))
1221 #  define COUNT(d) (d)
1222 # else
1223 /* not worth fixing */
1224 #  error "You cannot disable DES on systems without SIGALRM."
1225 # endif                        /* OPENSSL_NO_DES */
1226 #else
1227 # define COND(c) (run && count<0x7fffffff)
1228 # define COUNT(d) (count)
1229 # ifndef _WIN32
1230     signal(SIGALRM, sig_done);
1231 # endif
1232 #endif                         /* SIGALRM */
1233
1234 #ifndef OPENSSL_NO_MD2
1235     if (doit[D_MD2]) {
1236         for (j = 0; j < SIZE_NUM; j++) {
1237             print_message(names[D_MD2], c[D_MD2][j], lengths[j]);
1238             Time_F(START);
1239             for (count = 0, run = 1; COND(c[D_MD2][j]); count++)
1240                 EVP_Digest(buf, (unsigned long)lengths[j], &(md2[0]), NULL,
1241                            EVP_md2(), NULL);
1242             d = Time_F(STOP);
1243             print_result(D_MD2, j, count, d);
1244         }
1245     }
1246 #endif
1247 #ifndef OPENSSL_NO_MDC2
1248     if (doit[D_MDC2]) {
1249         for (j = 0; j < SIZE_NUM; j++) {
1250             print_message(names[D_MDC2], c[D_MDC2][j], lengths[j]);
1251             Time_F(START);
1252             for (count = 0, run = 1; COND(c[D_MDC2][j]); count++)
1253                 EVP_Digest(buf, (unsigned long)lengths[j], &(mdc2[0]), NULL,
1254                            EVP_mdc2(), NULL);
1255             d = Time_F(STOP);
1256             print_result(D_MDC2, j, count, d);
1257         }
1258     }
1259 #endif
1260
1261 #ifndef OPENSSL_NO_MD4
1262     if (doit[D_MD4]) {
1263         for (j = 0; j < SIZE_NUM; j++) {
1264             print_message(names[D_MD4], c[D_MD4][j], lengths[j]);
1265             Time_F(START);
1266             for (count = 0, run = 1; COND(c[D_MD4][j]); count++)
1267                 EVP_Digest(&(buf[0]), (unsigned long)lengths[j], &(md4[0]),
1268                            NULL, EVP_md4(), NULL);
1269             d = Time_F(STOP);
1270             print_result(D_MD4, j, count, d);
1271         }
1272     }
1273 #endif
1274
1275 #ifndef OPENSSL_NO_MD5
1276     if (doit[D_MD5]) {
1277         for (j = 0; j < SIZE_NUM; j++) {
1278             print_message(names[D_MD5], c[D_MD5][j], lengths[j]);
1279             Time_F(START);
1280             for (count = 0, run = 1; COND(c[D_MD5][j]); count++)
1281                 MD5(buf, lengths[j], md5);
1282             d = Time_F(STOP);
1283             print_result(D_MD5, j, count, d);
1284         }
1285     }
1286 #endif
1287
1288 #if !defined(OPENSSL_NO_MD5)
1289     if (doit[D_HMAC]) {
1290         HMAC_CTX *hctx = NULL;
1291
1292         hctx = HMAC_CTX_new();
1293         if (hctx == NULL) {
1294             BIO_printf(bio_err, "HMAC malloc failure, exiting...");
1295             exit(1);
1296         }
1297         HMAC_Init_ex(hctx, (unsigned char *)"This is a key...",
1298                      16, EVP_md5(), NULL);
1299
1300         for (j = 0; j < SIZE_NUM; j++) {
1301             print_message(names[D_HMAC], c[D_HMAC][j], lengths[j]);
1302             Time_F(START);
1303             for (count = 0, run = 1; COND(c[D_HMAC][j]); count++) {
1304                 HMAC_Init_ex(hctx, NULL, 0, NULL, NULL);
1305                 HMAC_Update(hctx, buf, lengths[j]);
1306                 HMAC_Final(hctx, &(hmac[0]), NULL);
1307             }
1308             d = Time_F(STOP);
1309             print_result(D_HMAC, j, count, d);
1310         }
1311         HMAC_CTX_free(hctx);
1312     }
1313 #endif
1314     if (doit[D_SHA1]) {
1315         for (j = 0; j < SIZE_NUM; j++) {
1316             print_message(names[D_SHA1], c[D_SHA1][j], lengths[j]);
1317             Time_F(START);
1318             for (count = 0, run = 1; COND(c[D_SHA1][j]); count++)
1319                 SHA1(buf, lengths[j], sha);
1320             d = Time_F(STOP);
1321             print_result(D_SHA1, j, count, d);
1322         }
1323     }
1324     if (doit[D_SHA256]) {
1325         for (j = 0; j < SIZE_NUM; j++) {
1326             print_message(names[D_SHA256], c[D_SHA256][j], lengths[j]);
1327             Time_F(START);
1328             for (count = 0, run = 1; COND(c[D_SHA256][j]); count++)
1329                 SHA256(buf, lengths[j], sha256);
1330             d = Time_F(STOP);
1331             print_result(D_SHA256, j, count, d);
1332         }
1333     }
1334     if (doit[D_SHA512]) {
1335         for (j = 0; j < SIZE_NUM; j++) {
1336             print_message(names[D_SHA512], c[D_SHA512][j], lengths[j]);
1337             Time_F(START);
1338             for (count = 0, run = 1; COND(c[D_SHA512][j]); count++)
1339                 SHA512(buf, lengths[j], sha512);
1340             d = Time_F(STOP);
1341             print_result(D_SHA512, j, count, d);
1342         }
1343     }
1344
1345 #ifndef OPENSSL_NO_WHIRLPOOL
1346     if (doit[D_WHIRLPOOL]) {
1347         for (j = 0; j < SIZE_NUM; j++) {
1348             print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][j], lengths[j]);
1349             Time_F(START);
1350             for (count = 0, run = 1; COND(c[D_WHIRLPOOL][j]); count++)
1351                 WHIRLPOOL(buf, lengths[j], whirlpool);
1352             d = Time_F(STOP);
1353             print_result(D_WHIRLPOOL, j, count, d);
1354         }
1355     }
1356 #endif
1357
1358 #ifndef OPENSSL_NO_RMD160
1359     if (doit[D_RMD160]) {
1360         for (j = 0; j < SIZE_NUM; j++) {
1361             print_message(names[D_RMD160], c[D_RMD160][j], lengths[j]);
1362             Time_F(START);
1363             for (count = 0, run = 1; COND(c[D_RMD160][j]); count++)
1364                 EVP_Digest(buf, (unsigned long)lengths[j], &(rmd160[0]), NULL,
1365                            EVP_ripemd160(), NULL);
1366             d = Time_F(STOP);
1367             print_result(D_RMD160, j, count, d);
1368         }
1369     }
1370 #endif
1371 #ifndef OPENSSL_NO_RC4
1372     if (doit[D_RC4]) {
1373         for (j = 0; j < SIZE_NUM; j++) {
1374             print_message(names[D_RC4], c[D_RC4][j], lengths[j]);
1375             Time_F(START);
1376             for (count = 0, run = 1; COND(c[D_RC4][j]); count++)
1377                 RC4(&rc4_ks, (unsigned int)lengths[j], buf, buf);
1378             d = Time_F(STOP);
1379             print_result(D_RC4, j, count, d);
1380         }
1381     }
1382 #endif
1383 #ifndef OPENSSL_NO_DES
1384     if (doit[D_CBC_DES]) {
1385         for (j = 0; j < SIZE_NUM; j++) {
1386             print_message(names[D_CBC_DES], c[D_CBC_DES][j], lengths[j]);
1387             Time_F(START);
1388             for (count = 0, run = 1; COND(c[D_CBC_DES][j]); count++)
1389                 DES_ncbc_encrypt(buf, buf, lengths[j], &sch,
1390                                  &DES_iv, DES_ENCRYPT);
1391             d = Time_F(STOP);
1392             print_result(D_CBC_DES, j, count, d);
1393         }
1394     }
1395
1396     if (doit[D_EDE3_DES]) {
1397         for (j = 0; j < SIZE_NUM; j++) {
1398             print_message(names[D_EDE3_DES], c[D_EDE3_DES][j], lengths[j]);
1399             Time_F(START);
1400             for (count = 0, run = 1; COND(c[D_EDE3_DES][j]); count++)
1401                 DES_ede3_cbc_encrypt(buf, buf, lengths[j],
1402                                      &sch, &sch2, &sch3,
1403                                      &DES_iv, DES_ENCRYPT);
1404             d = Time_F(STOP);
1405             print_result(D_EDE3_DES, j, count, d);
1406         }
1407     }
1408 #endif
1409 #ifndef OPENSSL_NO_AES
1410     if (doit[D_CBC_128_AES]) {
1411         for (j = 0; j < SIZE_NUM; j++) {
1412             print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][j],
1413                           lengths[j]);
1414             Time_F(START);
1415             for (count = 0, run = 1; COND(c[D_CBC_128_AES][j]); count++)
1416                 AES_cbc_encrypt(buf, buf,
1417                                 (unsigned long)lengths[j], &aes_ks1,
1418                                 iv, AES_ENCRYPT);
1419             d = Time_F(STOP);
1420             print_result(D_CBC_128_AES, j, count, d);
1421         }
1422     }
1423     if (doit[D_CBC_192_AES]) {
1424         for (j = 0; j < SIZE_NUM; j++) {
1425             print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][j],
1426                           lengths[j]);
1427             Time_F(START);
1428             for (count = 0, run = 1; COND(c[D_CBC_192_AES][j]); count++)
1429                 AES_cbc_encrypt(buf, buf,
1430                                 (unsigned long)lengths[j], &aes_ks2,
1431                                 iv, AES_ENCRYPT);
1432             d = Time_F(STOP);
1433             print_result(D_CBC_192_AES, j, count, d);
1434         }
1435     }
1436     if (doit[D_CBC_256_AES]) {
1437         for (j = 0; j < SIZE_NUM; j++) {
1438             print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][j],
1439                           lengths[j]);
1440             Time_F(START);
1441             for (count = 0, run = 1; COND(c[D_CBC_256_AES][j]); count++)
1442                 AES_cbc_encrypt(buf, buf,
1443                                 (unsigned long)lengths[j], &aes_ks3,
1444                                 iv, AES_ENCRYPT);
1445             d = Time_F(STOP);
1446             print_result(D_CBC_256_AES, j, count, d);
1447         }
1448     }
1449
1450     if (doit[D_IGE_128_AES]) {
1451         for (j = 0; j < SIZE_NUM; j++) {
1452             print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][j],
1453                           lengths[j]);
1454             Time_F(START);
1455             for (count = 0, run = 1; COND(c[D_IGE_128_AES][j]); count++)
1456                 AES_ige_encrypt(buf, buf2,
1457                                 (unsigned long)lengths[j], &aes_ks1,
1458                                 iv, AES_ENCRYPT);
1459             d = Time_F(STOP);
1460             print_result(D_IGE_128_AES, j, count, d);
1461         }
1462     }
1463     if (doit[D_IGE_192_AES]) {
1464         for (j = 0; j < SIZE_NUM; j++) {
1465             print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][j],
1466                           lengths[j]);
1467             Time_F(START);
1468             for (count = 0, run = 1; COND(c[D_IGE_192_AES][j]); count++)
1469                 AES_ige_encrypt(buf, buf2,
1470                                 (unsigned long)lengths[j], &aes_ks2,
1471                                 iv, AES_ENCRYPT);
1472             d = Time_F(STOP);
1473             print_result(D_IGE_192_AES, j, count, d);
1474         }
1475     }
1476     if (doit[D_IGE_256_AES]) {
1477         for (j = 0; j < SIZE_NUM; j++) {
1478             print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][j],
1479                           lengths[j]);
1480             Time_F(START);
1481             for (count = 0, run = 1; COND(c[D_IGE_256_AES][j]); count++)
1482                 AES_ige_encrypt(buf, buf2,
1483                                 (unsigned long)lengths[j], &aes_ks3,
1484                                 iv, AES_ENCRYPT);
1485             d = Time_F(STOP);
1486             print_result(D_IGE_256_AES, j, count, d);
1487         }
1488     }
1489     if (doit[D_GHASH]) {
1490         GCM128_CONTEXT *ctx =
1491             CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
1492         CRYPTO_gcm128_setiv(ctx, (unsigned char *)"0123456789ab", 12);
1493
1494         for (j = 0; j < SIZE_NUM; j++) {
1495             print_message(names[D_GHASH], c[D_GHASH][j], lengths[j]);
1496             Time_F(START);
1497             for (count = 0, run = 1; COND(c[D_GHASH][j]); count++)
1498                 CRYPTO_gcm128_aad(ctx, buf, lengths[j]);
1499             d = Time_F(STOP);
1500             print_result(D_GHASH, j, count, d);
1501         }
1502         CRYPTO_gcm128_release(ctx);
1503     }
1504 #endif
1505 #ifndef OPENSSL_NO_CAMELLIA
1506     if (doit[D_CBC_128_CML]) {
1507         for (j = 0; j < SIZE_NUM; j++) {
1508             print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][j],
1509                           lengths[j]);
1510             Time_F(START);
1511             for (count = 0, run = 1; COND(c[D_CBC_128_CML][j]); count++)
1512                 Camellia_cbc_encrypt(buf, buf,
1513                                      (unsigned long)lengths[j], &camellia_ks1,
1514                                      iv, CAMELLIA_ENCRYPT);
1515             d = Time_F(STOP);
1516             print_result(D_CBC_128_CML, j, count, d);
1517         }
1518     }
1519     if (doit[D_CBC_192_CML]) {
1520         for (j = 0; j < SIZE_NUM; j++) {
1521             print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][j],
1522                           lengths[j]);
1523             Time_F(START);
1524             for (count = 0, run = 1; COND(c[D_CBC_192_CML][j]); count++)
1525                 Camellia_cbc_encrypt(buf, buf,
1526                                      (unsigned long)lengths[j], &camellia_ks2,
1527                                      iv, CAMELLIA_ENCRYPT);
1528             d = Time_F(STOP);
1529             print_result(D_CBC_192_CML, j, count, d);
1530         }
1531     }
1532     if (doit[D_CBC_256_CML]) {
1533         for (j = 0; j < SIZE_NUM; j++) {
1534             print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][j],
1535                           lengths[j]);
1536             Time_F(START);
1537             for (count = 0, run = 1; COND(c[D_CBC_256_CML][j]); count++)
1538                 Camellia_cbc_encrypt(buf, buf,
1539                                      (unsigned long)lengths[j], &camellia_ks3,
1540                                      iv, CAMELLIA_ENCRYPT);
1541             d = Time_F(STOP);
1542             print_result(D_CBC_256_CML, j, count, d);
1543         }
1544     }
1545 #endif
1546 #ifndef OPENSSL_NO_IDEA
1547     if (doit[D_CBC_IDEA]) {
1548         for (j = 0; j < SIZE_NUM; j++) {
1549             print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][j], lengths[j]);
1550             Time_F(START);
1551             for (count = 0, run = 1; COND(c[D_CBC_IDEA][j]); count++)
1552                 idea_cbc_encrypt(buf, buf,
1553                                  (unsigned long)lengths[j], &idea_ks,
1554                                  iv, IDEA_ENCRYPT);
1555             d = Time_F(STOP);
1556             print_result(D_CBC_IDEA, j, count, d);
1557         }
1558     }
1559 #endif
1560 #ifndef OPENSSL_NO_SEED
1561     if (doit[D_CBC_SEED]) {
1562         for (j = 0; j < SIZE_NUM; j++) {
1563             print_message(names[D_CBC_SEED], c[D_CBC_SEED][j], lengths[j]);
1564             Time_F(START);
1565             for (count = 0, run = 1; COND(c[D_CBC_SEED][j]); count++)
1566                 SEED_cbc_encrypt(buf, buf,
1567                                  (unsigned long)lengths[j], &seed_ks, iv, 1);
1568             d = Time_F(STOP);
1569             print_result(D_CBC_SEED, j, count, d);
1570         }
1571     }
1572 #endif
1573 #ifndef OPENSSL_NO_RC2
1574     if (doit[D_CBC_RC2]) {
1575         for (j = 0; j < SIZE_NUM; j++) {
1576             print_message(names[D_CBC_RC2], c[D_CBC_RC2][j], lengths[j]);
1577             Time_F(START);
1578             for (count = 0, run = 1; COND(c[D_CBC_RC2][j]); count++)
1579                 RC2_cbc_encrypt(buf, buf,
1580                                 (unsigned long)lengths[j], &rc2_ks,
1581                                 iv, RC2_ENCRYPT);
1582             d = Time_F(STOP);
1583             print_result(D_CBC_RC2, j, count, d);
1584         }
1585     }
1586 #endif
1587 #ifndef OPENSSL_NO_RC5
1588     if (doit[D_CBC_RC5]) {
1589         for (j = 0; j < SIZE_NUM; j++) {
1590             print_message(names[D_CBC_RC5], c[D_CBC_RC5][j], lengths[j]);
1591             Time_F(START);
1592             for (count = 0, run = 1; COND(c[D_CBC_RC5][j]); count++)
1593                 RC5_32_cbc_encrypt(buf, buf,
1594                                    (unsigned long)lengths[j], &rc5_ks,
1595                                    iv, RC5_ENCRYPT);
1596             d = Time_F(STOP);
1597             print_result(D_CBC_RC5, j, count, d);
1598         }
1599     }
1600 #endif
1601 #ifndef OPENSSL_NO_BF
1602     if (doit[D_CBC_BF]) {
1603         for (j = 0; j < SIZE_NUM; j++) {
1604             print_message(names[D_CBC_BF], c[D_CBC_BF][j], lengths[j]);
1605             Time_F(START);
1606             for (count = 0, run = 1; COND(c[D_CBC_BF][j]); count++)
1607                 BF_cbc_encrypt(buf, buf,
1608                                (unsigned long)lengths[j], &bf_ks,
1609                                iv, BF_ENCRYPT);
1610             d = Time_F(STOP);
1611             print_result(D_CBC_BF, j, count, d);
1612         }
1613     }
1614 #endif
1615 #ifndef OPENSSL_NO_CAST
1616     if (doit[D_CBC_CAST]) {
1617         for (j = 0; j < SIZE_NUM; j++) {
1618             print_message(names[D_CBC_CAST], c[D_CBC_CAST][j], lengths[j]);
1619             Time_F(START);
1620             for (count = 0, run = 1; COND(c[D_CBC_CAST][j]); count++)
1621                 CAST_cbc_encrypt(buf, buf,
1622                                  (unsigned long)lengths[j], &cast_ks,
1623                                  iv, CAST_ENCRYPT);
1624             d = Time_F(STOP);
1625             print_result(D_CBC_CAST, j, count, d);
1626         }
1627     }
1628 #endif
1629
1630     if (doit[D_EVP]) {
1631 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
1632         if (multiblock && evp_cipher) {
1633             if (!
1634                 (EVP_CIPHER_flags(evp_cipher) &
1635                  EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
1636                 BIO_printf(bio_err, "%s is not multi-block capable\n",
1637                            OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
1638                 goto end;
1639             }
1640             multiblock_speed(evp_cipher);
1641             ret = 0;
1642             goto end;
1643         }
1644 #endif
1645         for (j = 0; j < SIZE_NUM; j++) {
1646             if (evp_cipher) {
1647                 EVP_CIPHER_CTX *ctx;
1648                 int outl;
1649
1650                 names[D_EVP] = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
1651                 /*
1652                  * -O3 -fschedule-insns messes up an optimization here!
1653                  * names[D_EVP] somehow becomes NULL
1654                  */
1655                 print_message(names[D_EVP], save_count, lengths[j]);
1656
1657                 ctx = EVP_CIPHER_CTX_new();
1658                 if (decrypt)
1659                     EVP_DecryptInit_ex(ctx, evp_cipher, NULL, key16, iv);
1660                 else
1661                     EVP_EncryptInit_ex(ctx, evp_cipher, NULL, key16, iv);
1662                 EVP_CIPHER_CTX_set_padding(ctx, 0);
1663
1664                 Time_F(START);
1665                 if (decrypt)
1666                     for (count = 0, run = 1;
1667                          COND(save_count * 4 * lengths[0] / lengths[j]);
1668                          count++)
1669                         EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[j]);
1670                 else
1671                     for (count = 0, run = 1;
1672                          COND(save_count * 4 * lengths[0] / lengths[j]);
1673                          count++)
1674                         EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[j]);
1675                 if (decrypt)
1676                     EVP_DecryptFinal_ex(ctx, buf, &outl);
1677                 else
1678                     EVP_EncryptFinal_ex(ctx, buf, &outl);
1679                 d = Time_F(STOP);
1680                 EVP_CIPHER_CTX_free(ctx);
1681             }
1682             if (evp_md) {
1683                 names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
1684                 print_message(names[D_EVP], save_count, lengths[j]);
1685
1686                 Time_F(START);
1687                 for (count = 0, run = 1;
1688                      COND(save_count * 4 * lengths[0] / lengths[j]); count++)
1689                     EVP_Digest(buf, lengths[j], &(md[0]), NULL, evp_md, NULL);
1690
1691                 d = Time_F(STOP);
1692             }
1693             print_result(D_EVP, j, count, d);
1694         }
1695     }
1696
1697     RAND_bytes(buf, 36);
1698 #ifndef OPENSSL_NO_RSA
1699     for (j = 0; j < RSA_NUM; j++) {
1700         int st;
1701         if (!rsa_doit[j])
1702             continue;
1703         st = RSA_sign(NID_md5_sha1, buf, 36, buf2, &rsa_num, rsa_key[j]);
1704         if (st == 0) {
1705             BIO_printf(bio_err,
1706                        "RSA sign failure.  No RSA sign will be done.\n");
1707             ERR_print_errors(bio_err);
1708             rsa_count = 1;
1709         } else {
1710             pkey_print_message("private", "rsa",
1711                                rsa_c[j][0], rsa_bits[j], RSA_SECONDS);
1712             /* RSA_blinding_on(rsa_key[j],NULL); */
1713             Time_F(START);
1714             for (count = 0, run = 1; COND(rsa_c[j][0]); count++) {
1715                 st = RSA_sign(NID_md5_sha1, buf, 36, buf2,
1716                               &rsa_num, rsa_key[j]);
1717                 if (st == 0) {
1718                     BIO_printf(bio_err, "RSA sign failure\n");
1719                     ERR_print_errors(bio_err);
1720                     count = 1;
1721                     break;
1722                 }
1723             }
1724             d = Time_F(STOP);
1725             BIO_printf(bio_err,
1726                        mr ? "+R1:%ld:%d:%.2f\n"
1727                        : "%ld %d bit private RSA's in %.2fs\n",
1728                        count, rsa_bits[j], d);
1729             rsa_results[j][0] = d / (double)count;
1730             rsa_count = count;
1731         }
1732
1733         st = RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[j]);
1734         if (st <= 0) {
1735             BIO_printf(bio_err,
1736                        "RSA verify failure.  No RSA verify will be done.\n");
1737             ERR_print_errors(bio_err);
1738             rsa_doit[j] = 0;
1739         } else {
1740             pkey_print_message("public", "rsa",
1741                                rsa_c[j][1], rsa_bits[j], RSA_SECONDS);
1742             Time_F(START);
1743             for (count = 0, run = 1; COND(rsa_c[j][1]); count++) {
1744                 st = RSA_verify(NID_md5_sha1, buf, 36, buf2,
1745                                 rsa_num, rsa_key[j]);
1746                 if (st <= 0) {
1747                     BIO_printf(bio_err, "RSA verify failure\n");
1748                     ERR_print_errors(bio_err);
1749                     count = 1;
1750                     break;
1751                 }
1752             }
1753             d = Time_F(STOP);
1754             BIO_printf(bio_err,
1755                        mr ? "+R2:%ld:%d:%.2f\n"
1756                        : "%ld %d bit public RSA's in %.2fs\n",
1757                        count, rsa_bits[j], d);
1758             rsa_results[j][1] = d / (double)count;
1759         }
1760
1761         if (rsa_count <= 1) {
1762             /* if longer than 10s, don't do any more */
1763             for (j++; j < RSA_NUM; j++)
1764                 rsa_doit[j] = 0;
1765         }
1766     }
1767 #endif
1768
1769     RAND_bytes(buf, 20);
1770 #ifndef OPENSSL_NO_DSA
1771     if (RAND_status() != 1) {
1772         RAND_seed(rnd_seed, sizeof rnd_seed);
1773         rnd_fake = 1;
1774     }
1775     for (j = 0; j < DSA_NUM; j++) {
1776         unsigned int kk;
1777         int st;
1778
1779         if (!dsa_doit[j])
1780             continue;
1781
1782         /* DSA_generate_key(dsa_key[j]); */
1783         /* DSA_sign_setup(dsa_key[j],NULL); */
1784         st = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]);
1785         if (st == 0) {
1786             BIO_printf(bio_err,
1787                        "DSA sign failure.  No DSA sign will be done.\n");
1788             ERR_print_errors(bio_err);
1789             rsa_count = 1;
1790         } else {
1791             pkey_print_message("sign", "dsa",
1792                                dsa_c[j][0], dsa_bits[j], DSA_SECONDS);
1793             Time_F(START);
1794             for (count = 0, run = 1; COND(dsa_c[j][0]); count++) {
1795                 st = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]);
1796                 if (st == 0) {
1797                     BIO_printf(bio_err, "DSA sign failure\n");
1798                     ERR_print_errors(bio_err);
1799                     count = 1;
1800                     break;
1801                 }
1802             }
1803             d = Time_F(STOP);
1804             BIO_printf(bio_err,
1805                        mr ? "+R3:%ld:%d:%.2f\n"
1806                        : "%ld %d bit DSA signs in %.2fs\n",
1807                        count, dsa_bits[j], d);
1808             dsa_results[j][0] = d / (double)count;
1809             rsa_count = count;
1810         }
1811
1812         st = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]);
1813         if (st <= 0) {
1814             BIO_printf(bio_err,
1815                        "DSA verify failure.  No DSA verify will be done.\n");
1816             ERR_print_errors(bio_err);
1817             dsa_doit[j] = 0;
1818         } else {
1819             pkey_print_message("verify", "dsa",
1820                                dsa_c[j][1], dsa_bits[j], DSA_SECONDS);
1821             Time_F(START);
1822             for (count = 0, run = 1; COND(dsa_c[j][1]); count++) {
1823                 st = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]);
1824                 if (st <= 0) {
1825                     BIO_printf(bio_err, "DSA verify failure\n");
1826                     ERR_print_errors(bio_err);
1827                     count = 1;
1828                     break;
1829                 }
1830             }
1831             d = Time_F(STOP);
1832             BIO_printf(bio_err,
1833                        mr ? "+R4:%ld:%d:%.2f\n"
1834                        : "%ld %d bit DSA verify in %.2fs\n",
1835                        count, dsa_bits[j], d);
1836             dsa_results[j][1] = d / (double)count;
1837         }
1838
1839         if (rsa_count <= 1) {
1840             /* if longer than 10s, don't do any more */
1841             for (j++; j < DSA_NUM; j++)
1842                 dsa_doit[j] = 0;
1843         }
1844     }
1845     if (rnd_fake)
1846         RAND_cleanup();
1847 #endif
1848
1849 #ifndef OPENSSL_NO_EC
1850     if (RAND_status() != 1) {
1851         RAND_seed(rnd_seed, sizeof rnd_seed);
1852         rnd_fake = 1;
1853     }
1854     for (j = 0; j < EC_NUM; j++) {
1855         int st;
1856
1857         if (!ecdsa_doit[j])
1858             continue;           /* Ignore Curve */
1859         ecdsa[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1860         if (ecdsa[j] == NULL) {
1861             BIO_printf(bio_err, "ECDSA failure.\n");
1862             ERR_print_errors(bio_err);
1863             rsa_count = 1;
1864         } else {
1865             EC_KEY_precompute_mult(ecdsa[j], NULL);
1866             /* Perform ECDSA signature test */
1867             EC_KEY_generate_key(ecdsa[j]);
1868             st = ECDSA_sign(0, buf, 20, ecdsasig, &ecdsasiglen, ecdsa[j]);
1869             if (st == 0) {
1870                 BIO_printf(bio_err,
1871                            "ECDSA sign failure.  No ECDSA sign will be done.\n");
1872                 ERR_print_errors(bio_err);
1873                 rsa_count = 1;
1874             } else {
1875                 pkey_print_message("sign", "ecdsa",
1876                                    ecdsa_c[j][0],
1877                                    test_curves_bits[j], ECDSA_SECONDS);
1878
1879                 Time_F(START);
1880                 for (count = 0, run = 1; COND(ecdsa_c[j][0]); count++) {
1881                     st = ECDSA_sign(0, buf, 20,
1882                                     ecdsasig, &ecdsasiglen, ecdsa[j]);
1883                     if (st == 0) {
1884                         BIO_printf(bio_err, "ECDSA sign failure\n");
1885                         ERR_print_errors(bio_err);
1886                         count = 1;
1887                         break;
1888                     }
1889                 }
1890                 d = Time_F(STOP);
1891
1892                 BIO_printf(bio_err,
1893                            mr ? "+R5:%ld:%d:%.2f\n" :
1894                            "%ld %d bit ECDSA signs in %.2fs \n",
1895                            count, test_curves_bits[j], d);
1896                 ecdsa_results[j][0] = d / (double)count;
1897                 rsa_count = count;
1898             }
1899
1900             /* Perform ECDSA verification test */
1901             st = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[j]);
1902             if (st != 1) {
1903                 BIO_printf(bio_err,
1904                            "ECDSA verify failure.  No ECDSA verify will be done.\n");
1905                 ERR_print_errors(bio_err);
1906                 ecdsa_doit[j] = 0;
1907             } else {
1908                 pkey_print_message("verify", "ecdsa",
1909                                    ecdsa_c[j][1],
1910                                    test_curves_bits[j], ECDSA_SECONDS);
1911                 Time_F(START);
1912                 for (count = 0, run = 1; COND(ecdsa_c[j][1]); count++) {
1913                     st = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen,
1914                                       ecdsa[j]);
1915                     if (st != 1) {
1916                         BIO_printf(bio_err, "ECDSA verify failure\n");
1917                         ERR_print_errors(bio_err);
1918                         count = 1;
1919                         break;
1920                     }
1921                 }
1922                 d = Time_F(STOP);
1923                 BIO_printf(bio_err,
1924                            mr ? "+R6:%ld:%d:%.2f\n"
1925                            : "%ld %d bit ECDSA verify in %.2fs\n",
1926                            count, test_curves_bits[j], d);
1927                 ecdsa_results[j][1] = d / (double)count;
1928             }
1929
1930             if (rsa_count <= 1) {
1931                 /* if longer than 10s, don't do any more */
1932                 for (j++; j < EC_NUM; j++)
1933                     ecdsa_doit[j] = 0;
1934             }
1935         }
1936     }
1937     if (rnd_fake)
1938         RAND_cleanup();
1939 #endif
1940
1941 #ifndef OPENSSL_NO_EC
1942     if (RAND_status() != 1) {
1943         RAND_seed(rnd_seed, sizeof rnd_seed);
1944         rnd_fake = 1;
1945     }
1946     for (j = 0; j < EC_NUM; j++) {
1947         if (!ecdh_doit[j])
1948             continue;
1949         ecdh_a[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1950         ecdh_b[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1951         if ((ecdh_a[j] == NULL) || (ecdh_b[j] == NULL)) {
1952             BIO_printf(bio_err, "ECDH failure.\n");
1953             ERR_print_errors(bio_err);
1954             rsa_count = 1;
1955         } else {
1956             /* generate two ECDH key pairs */
1957             if (!EC_KEY_generate_key(ecdh_a[j]) ||
1958                 !EC_KEY_generate_key(ecdh_b[j])) {
1959                 BIO_printf(bio_err, "ECDH key generation failure.\n");
1960                 ERR_print_errors(bio_err);
1961                 rsa_count = 1;
1962             } else {
1963                 /*
1964                  * If field size is not more than 24 octets, then use SHA-1
1965                  * hash of result; otherwise, use result (see section 4.8 of
1966                  * draft-ietf-tls-ecc-03.txt).
1967                  */
1968                 int field_size, outlen;
1969                 void *(*kdf) (const void *in, size_t inlen, void *out,
1970                               size_t *xoutlen);
1971                 field_size =
1972                     EC_GROUP_get_degree(EC_KEY_get0_group(ecdh_a[j]));
1973                 if (field_size <= 24 * 8) {
1974                     outlen = KDF1_SHA1_len;
1975                     kdf = KDF1_SHA1;
1976                 } else {
1977                     outlen = (field_size + 7) / 8;
1978                     kdf = NULL;
1979                 }
1980                 secret_size_a =
1981                     ECDH_compute_key(secret_a, outlen,
1982                                      EC_KEY_get0_public_key(ecdh_b[j]),
1983                                      ecdh_a[j], kdf);
1984                 secret_size_b =
1985                     ECDH_compute_key(secret_b, outlen,
1986                                      EC_KEY_get0_public_key(ecdh_a[j]),
1987                                      ecdh_b[j], kdf);
1988                 if (secret_size_a != secret_size_b)
1989                     ecdh_checks = 0;
1990                 else
1991                     ecdh_checks = 1;
1992
1993                 for (secret_idx = 0; (secret_idx < secret_size_a)
1994                      && (ecdh_checks == 1); secret_idx++) {
1995                     if (secret_a[secret_idx] != secret_b[secret_idx])
1996                         ecdh_checks = 0;
1997                 }
1998
1999                 if (ecdh_checks == 0) {
2000                     BIO_printf(bio_err, "ECDH computations don't match.\n");
2001                     ERR_print_errors(bio_err);
2002                     rsa_count = 1;
2003                 }
2004
2005                 pkey_print_message("", "ecdh",
2006                                    ecdh_c[j][0],
2007                                    test_curves_bits[j], ECDH_SECONDS);
2008                 Time_F(START);
2009                 for (count = 0, run = 1; COND(ecdh_c[j][0]); count++) {
2010                     ECDH_compute_key(secret_a, outlen,
2011                                      EC_KEY_get0_public_key(ecdh_b[j]),
2012                                      ecdh_a[j], kdf);
2013                 }
2014                 d = Time_F(STOP);
2015                 BIO_printf(bio_err,
2016                            mr ? "+R7:%ld:%d:%.2f\n" :
2017                            "%ld %d-bit ECDH ops in %.2fs\n", count,
2018                            test_curves_bits[j], d);
2019                 ecdh_results[j][0] = d / (double)count;
2020                 rsa_count = count;
2021             }
2022         }
2023
2024         if (rsa_count <= 1) {
2025             /* if longer than 10s, don't do any more */
2026             for (j++; j < EC_NUM; j++)
2027                 ecdh_doit[j] = 0;
2028         }
2029     }
2030     if (rnd_fake)
2031         RAND_cleanup();
2032 #endif
2033 #ifndef NO_FORK
2034  show_res:
2035 #endif
2036     if (!mr) {
2037         printf("%s\n", OpenSSL_version(OPENSSL_VERSION));
2038         printf("%s\n", OpenSSL_version(OPENSSL_BUILT_ON));
2039         printf("options:");
2040         printf("%s ", BN_options());
2041 #ifndef OPENSSL_NO_MD2
2042         printf("%s ", MD2_options());
2043 #endif
2044 #ifndef OPENSSL_NO_RC4
2045         printf("%s ", RC4_options());
2046 #endif
2047 #ifndef OPENSSL_NO_DES
2048         printf("%s ", DES_options());
2049 #endif
2050 #ifndef OPENSSL_NO_AES
2051         printf("%s ", AES_options());
2052 #endif
2053 #ifndef OPENSSL_NO_IDEA
2054         printf("%s ", idea_options());
2055 #endif
2056 #ifndef OPENSSL_NO_BF
2057         printf("%s ", BF_options());
2058 #endif
2059         printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
2060     }
2061
2062     if (pr_header) {
2063         if (mr)
2064             printf("+H");
2065         else {
2066             printf
2067                 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2068             printf("type        ");
2069         }
2070         for (j = 0; j < SIZE_NUM; j++)
2071             printf(mr ? ":%d" : "%7d bytes", lengths[j]);
2072         printf("\n");
2073     }
2074
2075     for (k = 0; k < ALGOR_NUM; k++) {
2076         if (!doit[k])
2077             continue;
2078         if (mr)
2079             printf("+F:%d:%s", k, names[k]);
2080         else
2081             printf("%-13s", names[k]);
2082         for (j = 0; j < SIZE_NUM; j++) {
2083             if (results[k][j] > 10000 && !mr)
2084                 printf(" %11.2fk", results[k][j] / 1e3);
2085             else
2086                 printf(mr ? ":%.2f" : " %11.2f ", results[k][j]);
2087         }
2088         printf("\n");
2089     }
2090 #ifndef OPENSSL_NO_RSA
2091     j = 1;
2092     for (k = 0; k < RSA_NUM; k++) {
2093         if (!rsa_doit[k])
2094             continue;
2095         if (j && !mr) {
2096             printf("%18ssign    verify    sign/s verify/s\n", " ");
2097             j = 0;
2098         }
2099         if (mr)
2100             printf("+F2:%u:%u:%f:%f\n",
2101                    k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2102         else
2103             printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2104                    rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2105                    1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2106     }
2107 #endif
2108 #ifndef OPENSSL_NO_DSA
2109     j = 1;
2110     for (k = 0; k < DSA_NUM; k++) {
2111         if (!dsa_doit[k])
2112             continue;
2113         if (j && !mr) {
2114             printf("%18ssign    verify    sign/s verify/s\n", " ");
2115             j = 0;
2116         }
2117         if (mr)
2118             printf("+F3:%u:%u:%f:%f\n",
2119                    k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2120         else
2121             printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2122                    dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2123                    1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2124     }
2125 #endif
2126 #ifndef OPENSSL_NO_EC
2127     j = 1;
2128     for (k = 0; k < EC_NUM; k++) {
2129         if (!ecdsa_doit[k])
2130             continue;
2131         if (j && !mr) {
2132             printf("%30ssign    verify    sign/s verify/s\n", " ");
2133             j = 0;
2134         }
2135
2136         if (mr)
2137             printf("+F4:%u:%u:%f:%f\n",
2138                    k, test_curves_bits[k],
2139                    ecdsa_results[k][0], ecdsa_results[k][1]);
2140         else
2141             printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2142                    test_curves_bits[k],
2143                    test_curves_names[k],
2144                    ecdsa_results[k][0], ecdsa_results[k][1],
2145                    1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2146     }
2147 #endif
2148
2149 #ifndef OPENSSL_NO_EC
2150     j = 1;
2151     for (k = 0; k < EC_NUM; k++) {
2152         if (!ecdh_doit[k])
2153             continue;
2154         if (j && !mr) {
2155             printf("%30sop      op/s\n", " ");
2156             j = 0;
2157         }
2158         if (mr)
2159             printf("+F5:%u:%u:%f:%f\n",
2160                    k, test_curves_bits[k],
2161                    ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2162
2163         else
2164             printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2165                    test_curves_bits[k],
2166                    test_curves_names[k],
2167                    ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2168     }
2169 #endif
2170
2171     ret = 0;
2172
2173  end:
2174     ERR_print_errors(bio_err);
2175     OPENSSL_free(buf_malloc);
2176     OPENSSL_free(buf2_malloc);
2177 #ifndef OPENSSL_NO_RSA
2178     for (i = 0; i < RSA_NUM; i++)
2179         RSA_free(rsa_key[i]);
2180 #endif
2181 #ifndef OPENSSL_NO_DSA
2182     for (i = 0; i < DSA_NUM; i++)
2183         DSA_free(dsa_key[i]);
2184 #endif
2185
2186 #ifndef OPENSSL_NO_EC
2187     for (i = 0; i < EC_NUM; i++) {
2188         EC_KEY_free(ecdsa[i]);
2189         EC_KEY_free(ecdh_a[i]);
2190         EC_KEY_free(ecdh_b[i]);
2191     }
2192 #endif
2193     return (ret);
2194 }
2195
2196 static void print_message(const char *s, long num, int length)
2197 {
2198 #ifdef SIGALRM
2199     BIO_printf(bio_err,
2200                mr ? "+DT:%s:%d:%d\n"
2201                : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2202     (void)BIO_flush(bio_err);
2203     alarm(SECONDS);
2204 #else
2205     BIO_printf(bio_err,
2206                mr ? "+DN:%s:%ld:%d\n"
2207                : "Doing %s %ld times on %d size blocks: ", s, num, length);
2208     (void)BIO_flush(bio_err);
2209 #endif
2210 }
2211
2212 static void pkey_print_message(const char *str, const char *str2, long num,
2213                                int bits, int tm)
2214 {
2215 #ifdef SIGALRM
2216     BIO_printf(bio_err,
2217                mr ? "+DTP:%d:%s:%s:%d\n"
2218                : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2219     (void)BIO_flush(bio_err);
2220     alarm(tm);
2221 #else
2222     BIO_printf(bio_err,
2223                mr ? "+DNP:%ld:%d:%s:%s\n"
2224                : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2225     (void)BIO_flush(bio_err);
2226 #endif
2227 }
2228
2229 static void print_result(int alg, int run_no, int count, double time_used)
2230 {
2231     BIO_printf(bio_err,
2232                mr ? "+R:%d:%s:%f\n"
2233                : "%d %s's in %.2fs\n", count, names[alg], time_used);
2234     results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2235 }
2236
2237 #ifndef NO_FORK
2238 static char *sstrsep(char **string, const char *delim)
2239 {
2240     char isdelim[256];
2241     char *token = *string;
2242
2243     if (**string == 0)
2244         return NULL;
2245
2246     memset(isdelim, 0, sizeof isdelim);
2247     isdelim[0] = 1;
2248
2249     while (*delim) {
2250         isdelim[(unsigned char)(*delim)] = 1;
2251         delim++;
2252     }
2253
2254     while (!isdelim[(unsigned char)(**string)]) {
2255         (*string)++;
2256     }
2257
2258     if (**string) {
2259         **string = 0;
2260         (*string)++;
2261     }
2262
2263     return token;
2264 }
2265
2266 static int do_multi(int multi)
2267 {
2268     int n;
2269     int fd[2];
2270     int *fds;
2271     static char sep[] = ":";
2272
2273     fds = malloc(sizeof(*fds) * multi);
2274     for (n = 0; n < multi; ++n) {
2275         if (pipe(fd) == -1) {
2276             BIO_printf(bio_err, "pipe failure\n");
2277             exit(1);
2278         }
2279         fflush(stdout);
2280         (void)BIO_flush(bio_err);
2281         if (fork()) {
2282             close(fd[1]);
2283             fds[n] = fd[0];
2284         } else {
2285             close(fd[0]);
2286             close(1);
2287             if (dup(fd[1]) == -1) {
2288                 BIO_printf(bio_err, "dup failed\n");
2289                 exit(1);
2290             }
2291             close(fd[1]);
2292             mr = 1;
2293             usertime = 0;
2294             free(fds);
2295             return 0;
2296         }
2297         printf("Forked child %d\n", n);
2298     }
2299
2300     /* for now, assume the pipe is long enough to take all the output */
2301     for (n = 0; n < multi; ++n) {
2302         FILE *f;
2303         char buf[1024];
2304         char *p;
2305
2306         f = fdopen(fds[n], "r");
2307         while (fgets(buf, sizeof buf, f)) {
2308             p = strchr(buf, '\n');
2309             if (p)
2310                 *p = '\0';
2311             if (buf[0] != '+') {
2312                 BIO_printf(bio_err, "Don't understand line '%s' from child %d\n",
2313                         buf, n);
2314                 continue;
2315             }
2316             printf("Got: %s from %d\n", buf, n);
2317             if (strncmp(buf, "+F:", 3) == 0) {
2318                 int alg;
2319                 int j;
2320
2321                 p = buf + 3;
2322                 alg = atoi(sstrsep(&p, sep));
2323                 sstrsep(&p, sep);
2324                 for (j = 0; j < SIZE_NUM; ++j)
2325                     results[alg][j] += atof(sstrsep(&p, sep));
2326             } else if (strncmp(buf, "+F2:", 4) == 0) {
2327                 int k;
2328                 double d;
2329
2330                 p = buf + 4;
2331                 k = atoi(sstrsep(&p, sep));
2332                 sstrsep(&p, sep);
2333
2334                 d = atof(sstrsep(&p, sep));
2335                 if (n)
2336                     rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
2337                 else
2338                     rsa_results[k][0] = d;
2339
2340                 d = atof(sstrsep(&p, sep));
2341                 if (n)
2342                     rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
2343                 else
2344                     rsa_results[k][1] = d;
2345             }
2346 # ifndef OPENSSL_NO_DSA
2347             else if (strncmp(buf, "+F3:", 4) == 0) {
2348                 int k;
2349                 double d;
2350
2351                 p = buf + 4;
2352                 k = atoi(sstrsep(&p, sep));
2353                 sstrsep(&p, sep);
2354
2355                 d = atof(sstrsep(&p, sep));
2356                 if (n)
2357                     dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
2358                 else
2359                     dsa_results[k][0] = d;
2360
2361                 d = atof(sstrsep(&p, sep));
2362                 if (n)
2363                     dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
2364                 else
2365                     dsa_results[k][1] = d;
2366             }
2367 # endif
2368 # ifndef OPENSSL_NO_EC
2369             else if (strncmp(buf, "+F4:", 4) == 0) {
2370                 int k;
2371                 double d;
2372
2373                 p = buf + 4;
2374                 k = atoi(sstrsep(&p, sep));
2375                 sstrsep(&p, sep);
2376
2377                 d = atof(sstrsep(&p, sep));
2378                 if (n)
2379                     ecdsa_results[k][0] =
2380                         1 / (1 / ecdsa_results[k][0] + 1 / d);
2381                 else
2382                     ecdsa_results[k][0] = d;
2383
2384                 d = atof(sstrsep(&p, sep));
2385                 if (n)
2386                     ecdsa_results[k][1] =
2387                         1 / (1 / ecdsa_results[k][1] + 1 / d);
2388                 else
2389                     ecdsa_results[k][1] = d;
2390             }
2391 # endif
2392
2393 # ifndef OPENSSL_NO_EC
2394             else if (strncmp(buf, "+F5:", 4) == 0) {
2395                 int k;
2396                 double d;
2397
2398                 p = buf + 4;
2399                 k = atoi(sstrsep(&p, sep));
2400                 sstrsep(&p, sep);
2401
2402                 d = atof(sstrsep(&p, sep));
2403                 if (n)
2404                     ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
2405                 else
2406                     ecdh_results[k][0] = d;
2407
2408             }
2409 # endif
2410
2411             else if (strncmp(buf, "+H:", 3) == 0) {
2412                 ;
2413             } else
2414                 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf, n);
2415         }
2416
2417         fclose(f);
2418     }
2419     free(fds);
2420     return 1;
2421 }
2422 #endif
2423
2424 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
2425 {
2426     static int mblengths[] =
2427         { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
2428     int j, count, num = OSSL_NELEM(lengths);
2429     const char *alg_name;
2430     unsigned char *inp, *out, no_key[32], no_iv[16];
2431     EVP_CIPHER_CTX *ctx;
2432     double d = 0.0;
2433
2434     inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
2435     out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
2436     ctx = EVP_CIPHER_CTX_new();
2437     EVP_EncryptInit_ex(ctx, evp_cipher, NULL, no_key, no_iv);
2438     EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key),
2439                         no_key);
2440     alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
2441
2442     for (j = 0; j < num; j++) {
2443         print_message(alg_name, 0, mblengths[j]);
2444         Time_F(START);
2445         for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
2446             unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
2447             EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
2448             size_t len = mblengths[j];
2449             int packlen;
2450
2451             memset(aad, 0, 8);  /* avoid uninitialized values */
2452             aad[8] = 23;        /* SSL3_RT_APPLICATION_DATA */
2453             aad[9] = 3;         /* version */
2454             aad[10] = 2;
2455             aad[11] = 0;        /* length */
2456             aad[12] = 0;
2457             mb_param.out = NULL;
2458             mb_param.inp = aad;
2459             mb_param.len = len;
2460             mb_param.interleave = 8;
2461
2462             packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
2463                                           sizeof(mb_param), &mb_param);
2464
2465             if (packlen > 0) {
2466                 mb_param.out = out;
2467                 mb_param.inp = inp;
2468                 mb_param.len = len;
2469                 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
2470                                     sizeof(mb_param), &mb_param);
2471             } else {
2472                 int pad;
2473
2474                 RAND_bytes(out, 16);
2475                 len += 16;
2476                 aad[11] = len >> 8;
2477                 aad[12] = len;
2478                 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
2479                                           EVP_AEAD_TLS1_AAD_LEN, aad);
2480                 EVP_Cipher(ctx, out, inp, len + pad);
2481             }
2482         }
2483         d = Time_F(STOP);
2484         BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
2485                    : "%d %s's in %.2fs\n", count, "evp", d);
2486         results[D_EVP][j] = ((double)count) / d * mblengths[j];
2487     }
2488
2489     if (mr) {
2490         fprintf(stdout, "+H");
2491         for (j = 0; j < num; j++)
2492             fprintf(stdout, ":%d", mblengths[j]);
2493         fprintf(stdout, "\n");
2494         fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
2495         for (j = 0; j < num; j++)
2496             fprintf(stdout, ":%.2f", results[D_EVP][j]);
2497         fprintf(stdout, "\n");
2498     } else {
2499         fprintf(stdout,
2500                 "The 'numbers' are in 1000s of bytes per second processed.\n");
2501         fprintf(stdout, "type                    ");
2502         for (j = 0; j < num; j++)
2503             fprintf(stdout, "%7d bytes", mblengths[j]);
2504         fprintf(stdout, "\n");
2505         fprintf(stdout, "%-24s", alg_name);
2506
2507         for (j = 0; j < num; j++) {
2508             if (results[D_EVP][j] > 10000)
2509                 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
2510             else
2511                 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
2512         }
2513         fprintf(stdout, "\n");
2514     }
2515
2516     OPENSSL_free(inp);
2517     OPENSSL_free(out);
2518     EVP_CIPHER_CTX_free(ctx);
2519 }