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