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