apps/speed.c

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