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