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