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