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                         dsa_doit[R_DSA_2048]=1;
 980                         }
 981                 else
 982 #endif
 983 #ifndef OPENSSL_NO_ECDSA
 984                      if (strcmp(*argv,"ecdsap160") == 0) ecdsa_doit[R_EC_P160]=2;
 985                 else if (strcmp(*argv,"ecdsap224") == 0) ecdsa_doit[R_EC_P224]=2;
 986                 else if (strcmp(*argv,"ecdsap256") == 0) ecdsa_doit[R_EC_P256]=2;
 987                 else if (strcmp(*argv,"ecdsap384") == 0) ecdsa_doit[R_EC_P384]=2;
 988                 else if (strcmp(*argv,"ecdsap521") == 0) ecdsa_doit[R_EC_P521]=2;
 989                 else if (strcmp(*argv,"ecdsak163") == 0) ecdsa_doit[R_EC_K163]=2;
 990                 else if (strcmp(*argv,"ecdsak233") == 0) ecdsa_doit[R_EC_K233]=2;
 991                 else if (strcmp(*argv,"ecdsak283") == 0) ecdsa_doit[R_EC_K283]=2;
 992                 else if (strcmp(*argv,"ecdsak409") == 0) ecdsa_doit[R_EC_K409]=2;
 993                 else if (strcmp(*argv,"ecdsak571") == 0) ecdsa_doit[R_EC_K571]=2;
 994                 else if (strcmp(*argv,"ecdsab163") == 0) ecdsa_doit[R_EC_B163]=2;
 995                 else if (strcmp(*argv,"ecdsab233") == 0) ecdsa_doit[R_EC_B233]=2;
 996                 else if (strcmp(*argv,"ecdsab283") == 0) ecdsa_doit[R_EC_B283]=2;
 997                 else if (strcmp(*argv,"ecdsab409") == 0) ecdsa_doit[R_EC_B409]=2;
 998                 else if (strcmp(*argv,"ecdsab571") == 0) ecdsa_doit[R_EC_B571]=2;
 999                 else if (strcmp(*argv,"ecdsa") == 0)
1000                         {
1001                         for (i=0; i < EC_NUM; i++)
1002                                 ecdsa_doit[i]=1;
1003                         }
1004                 else
1005 #endif
1006 #ifndef OPENSSL_NO_ECDH
1007                      if (strcmp(*argv,"ecdhp160") == 0) ecdh_doit[R_EC_P160]=2;
1008                 else if (strcmp(*argv,"ecdhp224") == 0) ecdh_doit[R_EC_P224]=2;
1009                 else if (strcmp(*argv,"ecdhp256") == 0) ecdh_doit[R_EC_P256]=2;
1010                 else if (strcmp(*argv,"ecdhp384") == 0) ecdh_doit[R_EC_P384]=2;
1011                 else if (strcmp(*argv,"ecdhp521") == 0) ecdh_doit[R_EC_P521]=2;
1012                 else if (strcmp(*argv,"ecdhk163") == 0) ecdh_doit[R_EC_K163]=2;
1013                 else if (strcmp(*argv,"ecdhk233") == 0) ecdh_doit[R_EC_K233]=2;
1014                 else if (strcmp(*argv,"ecdhk283") == 0) ecdh_doit[R_EC_K283]=2;
1015                 else if (strcmp(*argv,"ecdhk409") == 0) ecdh_doit[R_EC_K409]=2;
1016                 else if (strcmp(*argv,"ecdhk571") == 0) ecdh_doit[R_EC_K571]=2;
1017                 else if (strcmp(*argv,"ecdhb163") == 0) ecdh_doit[R_EC_B163]=2;
1018                 else if (strcmp(*argv,"ecdhb233") == 0) ecdh_doit[R_EC_B233]=2;
1019                 else if (strcmp(*argv,"ecdhb283") == 0) ecdh_doit[R_EC_B283]=2;
1020                 else if (strcmp(*argv,"ecdhb409") == 0) ecdh_doit[R_EC_B409]=2;
1021                 else if (strcmp(*argv,"ecdhb571") == 0) ecdh_doit[R_EC_B571]=2;
1022                 else if (strcmp(*argv,"ecdh") == 0)
1023                         {
1024                         for (i=0; i < EC_NUM; i++)
1025                                 ecdh_doit[i]=1;
1026                         }
1027                 else
1028 #endif
1029                         {
1030                         BIO_printf(bio_err,"Error: bad option or value\n");
1031                         BIO_printf(bio_err,"\n");
1032                         BIO_printf(bio_err,"Available values:\n");
1033 #ifndef OPENSSL_NO_MD2
1034                         BIO_printf(bio_err,"md2      ");
1035 #endif
1036 #ifndef OPENSSL_NO_MDC2
1037                         BIO_printf(bio_err,"mdc2     ");
1038 #endif
1039 #ifndef OPENSSL_NO_MD4
1040                         BIO_printf(bio_err,"md4      ");
1041 #endif
1042 #ifndef OPENSSL_NO_MD5
1043                         BIO_printf(bio_err,"md5      ");
1044 #ifndef OPENSSL_NO_HMAC
1045                         BIO_printf(bio_err,"hmac     ");
1046 #endif
1047 #endif
1048 #ifndef OPENSSL_NO_SHA1
1049                         BIO_printf(bio_err,"sha1     ");
1050 #endif
1051 #ifndef OPENSSL_NO_RIPEMD160
1052                         BIO_printf(bio_err,"rmd160");
1053 #endif
1054 #if !defined(OPENSSL_NO_MD2) || !defined(OPENSSL_NO_MDC2) || \
1055     !defined(OPENSSL_NO_MD4) || !defined(OPENSSL_NO_MD5) || \
1056     !defined(OPENSSL_NO_SHA1) || !defined(OPENSSL_NO_RIPEMD160)
1057                         BIO_printf(bio_err,"\n");
1058 #endif
1059
1060 #ifndef OPENSSL_NO_IDEA
1061                         BIO_printf(bio_err,"idea-cbc ");
1062 #endif
1063 #ifndef OPENSSL_NO_RC2
1064                         BIO_printf(bio_err,"rc2-cbc  ");
1065 #endif
1066 #ifndef OPENSSL_NO_RC5
1067                         BIO_printf(bio_err,"rc5-cbc  ");
1068 #endif
1069 #ifndef OPENSSL_NO_BF
1070                         BIO_printf(bio_err,"bf-cbc");
1071 #endif
1072 #if !defined(OPENSSL_NO_IDEA) || !defined(OPENSSL_NO_RC2) || \
1073     !defined(OPENSSL_NO_BF) || !defined(OPENSSL_NO_RC5)
1074                         BIO_printf(bio_err,"\n");
1075 #endif
1076 #ifndef OPENSSL_NO_DES
1077                         BIO_printf(bio_err,"des-cbc  des-ede3 ");
1078 #endif
1079 #ifndef OPENSSL_NO_AES
1080                         BIO_printf(bio_err,"aes-128-cbc aes-192-cbc aes-256-cbc ");
1081 #endif
1082 #ifndef OPENSSL_NO_RC4
1083                         BIO_printf(bio_err,"rc4");
1084 #endif
1085                         BIO_printf(bio_err,"\n");
1086
1087 #ifndef OPENSSL_NO_RSA
1088                         BIO_printf(bio_err,"rsa512   rsa1024  rsa2048  rsa4096\n");
1089 #endif
1090
1091 #ifndef OPENSSL_NO_DSA
1092                         BIO_printf(bio_err,"dsa512   dsa1024  dsa2048\n");
1093 #endif
1094 #ifndef OPENSSL_NO_ECDSA
1095                         BIO_printf(bio_err,"ecdsap160 ecdsap224 ecdsap256 ecdsap384 ecdsap521\n");
1096                         BIO_printf(bio_err,"ecdsak163 ecdsak233 ecdsak283 ecdsak409 ecdsak571\n");
1097                         BIO_printf(bio_err,"ecdsab163 ecdsab233 ecdsab283 ecdsab409 ecdsab571\n");
1098                         BIO_printf(bio_err,"ecdsa\n");
1099 #endif
1100 #ifndef OPENSSL_NO_ECDH
1101                         BIO_printf(bio_err,"ecdhp160  ecdhp224  ecdhp256  ecdhp384  ecdhp521\n");
1102                         BIO_printf(bio_err,"ecdhk163  ecdhk233  ecdhk283  ecdhk409  ecdhk571\n");
1103                         BIO_printf(bio_err,"ecdhb163  ecdhb233  ecdhb283  ecdhb409  ecdhb571\n");
1104                         BIO_printf(bio_err,"ecdh\n");
1105 #endif
1106
1107 #ifndef OPENSSL_NO_IDEA
1108                         BIO_printf(bio_err,"idea     ");
1109 #endif
1110 #ifndef OPENSSL_NO_RC2
1111                         BIO_printf(bio_err,"rc2      ");
1112 #endif
1113 #ifndef OPENSSL_NO_DES
1114                         BIO_printf(bio_err,"des      ");
1115 #endif
1116 #ifndef OPENSSL_NO_AES
1117                         BIO_printf(bio_err,"aes      ");
1118 #endif
1119 #ifndef OPENSSL_NO_RSA
1120                         BIO_printf(bio_err,"rsa      ");
1121 #endif
1122 #ifndef OPENSSL_NO_BF
1123                         BIO_printf(bio_err,"blowfish");
1124 #endif
1125 #if !defined(OPENSSL_NO_IDEA) || !defined(OPENSSL_NO_RC2) || \
1126     !defined(OPENSSL_NO_DES) || !defined(OPENSSL_NO_RSA) || \
1127     !defined(OPENSSL_NO_BF) || !defined(OPENSSL_NO_AES)
1128                         BIO_printf(bio_err,"\n");
1129 #endif
1130
1131                         BIO_printf(bio_err,"\n");
1132                         BIO_printf(bio_err,"Available options:\n");
1133 #if defined(TIMES) || defined(USE_TOD)
1134                         BIO_printf(bio_err,"-elapsed        measure time in real time instead of CPU user time.\n");
1135 #endif
1136 #ifndef OPENSSL_NO_ENGINE
1137                         BIO_printf(bio_err,"-engine e       use engine e, possibly a hardware device.\n");
1138 #endif
1139                         BIO_printf(bio_err,"-evp e          use EVP e.\n");
1140                         BIO_printf(bio_err,"-decrypt        time decryption instead of encryption (only EVP).\n");
1141                         BIO_printf(bio_err,"-mr             produce machine readable output.\n");
1142 #ifdef HAVE_FORK
1143                         BIO_printf(bio_err,"-multi n        run n benchmarks in parallel.\n");
1144 #endif
1145                         goto end;
1146                         }
1147                 argc--;
1148                 argv++;
1149                 j++;
1150                 }
1151
1152 #ifdef HAVE_FORK
1153         if(multi && do_multi(multi))
1154                 goto show_res;
1155 #endif
1156
1157         if (j == 0)
1158                 {
1159                 for (i=0; i<ALGOR_NUM; i++)
1160                         {
1161                         if (i != D_EVP)
1162                                 doit[i]=1;
1163                         }
1164                 for (i=0; i<RSA_NUM; i++)
1165                         rsa_doit[i]=1;
1166                 for (i=0; i<DSA_NUM; i++)
1167                         dsa_doit[i]=1;
1168                 }
1169         for (i=0; i<ALGOR_NUM; i++)
1170                 if (doit[i]) pr_header++;
1171
1172         if (usertime == 0 && !mr)
1173                 BIO_printf(bio_err,"You have chosen to measure elapsed time instead of user CPU time.\n");
1174         if (usertime <= 0 && !mr)
1175                 {
1176                 BIO_printf(bio_err,"To get the most accurate results, try to run this\n");
1177                 BIO_printf(bio_err,"program when this computer is idle.\n");
1178                 }
1179
1180 #ifndef OPENSSL_NO_RSA
1181         for (i=0; i<RSA_NUM; i++)
1182                 {
1183                 const unsigned char *p;
1184
1185                 p=rsa_data[i];
1186                 rsa_key[i]=d2i_RSAPrivateKey(NULL,&p,rsa_data_length[i]);
1187                 if (rsa_key[i] == NULL)
1188                         {
1189                         BIO_printf(bio_err,"internal error loading RSA key number %d\n",i);
1190                         goto end;
1191                         }
1192 #if 0
1193                 else
1194                         {
1195                         BIO_printf(bio_err,mr ? "+RK:%d:"
1196                                    : "Loaded RSA key, %d bit modulus and e= 0x",
1197                                    BN_num_bits(rsa_key[i]->n));
1198                         BN_print(bio_err,rsa_key[i]->e);
1199                         BIO_printf(bio_err,"\n");
1200                         }
1201 #endif
1202                 }
1203 #endif
1204
1205 #ifndef OPENSSL_NO_DSA
1206         dsa_key[0]=get_dsa512();
1207         dsa_key[1]=get_dsa1024();
1208         dsa_key[2]=get_dsa2048();
1209 #endif
1210
1211 #ifndef OPENSSL_NO_DES
1212         DES_set_key_unchecked(&key,&sch);
1213         DES_set_key_unchecked(&key2,&sch2);
1214         DES_set_key_unchecked(&key3,&sch3);
1215 #endif
1216 #ifndef OPENSSL_NO_AES
1217         AES_set_encrypt_key(key16,128,&aes_ks1);
1218         AES_set_encrypt_key(key24,192,&aes_ks2);
1219         AES_set_encrypt_key(key32,256,&aes_ks3);
1220 #endif
1221 #ifndef OPENSSL_NO_IDEA
1222         idea_set_encrypt_key(key16,&idea_ks);
1223 #endif
1224 #ifndef OPENSSL_NO_RC4
1225         RC4_set_key(&rc4_ks,16,key16);
1226 #endif
1227 #ifndef OPENSSL_NO_RC2
1228         RC2_set_key(&rc2_ks,16,key16,128);
1229 #endif
1230 #ifndef OPENSSL_NO_RC5
1231         RC5_32_set_key(&rc5_ks,16,key16,12);
1232 #endif
1233 #ifndef OPENSSL_NO_BF
1234         BF_set_key(&bf_ks,16,key16);
1235 #endif
1236 #ifndef OPENSSL_NO_CAST
1237         CAST_set_key(&cast_ks,16,key16);
1238 #endif
1239 #ifndef OPENSSL_NO_RSA
1240         memset(rsa_c,0,sizeof(rsa_c));
1241 #endif
1242 #ifndef SIGALRM
1243 #ifndef OPENSSL_NO_DES
1244         BIO_printf(bio_err,"First we calculate the approximate speed ...\n");
1245         count=10;
1246         do      {
1247                 long i;
1248                 count*=2;
1249                 Time_F(START);
1250                 for (i=count; i; i--)
1251                         DES_ecb_encrypt(buf_as_des_cblock,buf_as_des_cblock,
1252                                 &sch,DES_ENCRYPT);
1253                 d=Time_F(STOP);
1254                 } while (d <3);
1255         save_count=count;
1256         c[D_MD2][0]=count/10;
1257         c[D_MDC2][0]=count/10;
1258         c[D_MD4][0]=count;
1259         c[D_MD5][0]=count;
1260         c[D_HMAC][0]=count;
1261         c[D_SHA1][0]=count;
1262         c[D_RMD160][0]=count;
1263         c[D_RC4][0]=count*5;
1264         c[D_CBC_DES][0]=count;
1265         c[D_EDE3_DES][0]=count/3;
1266         c[D_CBC_IDEA][0]=count;
1267         c[D_CBC_RC2][0]=count;
1268         c[D_CBC_RC5][0]=count;
1269         c[D_CBC_BF][0]=count;
1270         c[D_CBC_CAST][0]=count;
1271         c[D_CBC_128_AES][0]=count;
1272         c[D_CBC_192_AES][0]=count;
1273         c[D_CBC_256_AES][0]=count;
1274
1275         for (i=1; i<SIZE_NUM; i++)
1276                 {
1277                 c[D_MD2][i]=c[D_MD2][0]*4*lengths[0]/lengths[i];
1278                 c[D_MDC2][i]=c[D_MDC2][0]*4*lengths[0]/lengths[i];
1279                 c[D_MD4][i]=c[D_MD4][0]*4*lengths[0]/lengths[i];
1280                 c[D_MD5][i]=c[D_MD5][0]*4*lengths[0]/lengths[i];
1281                 c[D_HMAC][i]=c[D_HMAC][0]*4*lengths[0]/lengths[i];
1282                 c[D_SHA1][i]=c[D_SHA1][0]*4*lengths[0]/lengths[i];
1283                 c[D_RMD160][i]=c[D_RMD160][0]*4*lengths[0]/lengths[i];
1284                 }
1285         for (i=1; i<SIZE_NUM; i++)
1286                 {
1287                 long l0,l1;
1288
1289                 l0=(long)lengths[i-1];
1290                 l1=(long)lengths[i];
1291                 c[D_RC4][i]=c[D_RC4][i-1]*l0/l1;
1292                 c[D_CBC_DES][i]=c[D_CBC_DES][i-1]*l0/l1;
1293                 c[D_EDE3_DES][i]=c[D_EDE3_DES][i-1]*l0/l1;
1294                 c[D_CBC_IDEA][i]=c[D_CBC_IDEA][i-1]*l0/l1;
1295                 c[D_CBC_RC2][i]=c[D_CBC_RC2][i-1]*l0/l1;
1296                 c[D_CBC_RC5][i]=c[D_CBC_RC5][i-1]*l0/l1;
1297                 c[D_CBC_BF][i]=c[D_CBC_BF][i-1]*l0/l1;
1298                 c[D_CBC_CAST][i]=c[D_CBC_CAST][i-1]*l0/l1;
1299                 c[D_CBC_128_AES][i]=c[D_CBC_128_AES][i-1]*l0/l1;
1300                 c[D_CBC_192_AES][i]=c[D_CBC_192_AES][i-1]*l0/l1;
1301                 c[D_CBC_256_AES][i]=c[D_CBC_256_AES][i-1]*l0/l1;
1302                 }
1303 #ifndef OPENSSL_NO_RSA
1304         rsa_c[R_RSA_512][0]=count/2000;
1305         rsa_c[R_RSA_512][1]=count/400;
1306         for (i=1; i<RSA_NUM; i++)
1307                 {
1308                 rsa_c[i][0]=rsa_c[i-1][0]/8;
1309                 rsa_c[i][1]=rsa_c[i-1][1]/4;
1310                 if ((rsa_doit[i] <= 1) && (rsa_c[i][0] == 0))
1311                         rsa_doit[i]=0;
1312                 else
1313                         {
1314                         if (rsa_c[i][0] == 0)
1315                                 {
1316                                 rsa_c[i][0]=1;
1317                                 rsa_c[i][1]=20;
1318                                 }
1319                         }
1320                 }
1321 #endif
1322
1323 #ifndef OPENSSL_NO_DSA
1324         dsa_c[R_DSA_512][0]=count/1000;
1325         dsa_c[R_DSA_512][1]=count/1000/2;
1326         for (i=1; i<DSA_NUM; i++)
1327                 {
1328                 dsa_c[i][0]=dsa_c[i-1][0]/4;
1329                 dsa_c[i][1]=dsa_c[i-1][1]/4;
1330                 if ((dsa_doit[i] <= 1) && (dsa_c[i][0] == 0))
1331                         dsa_doit[i]=0;
1332                 else
1333                         {
1334                         if (dsa_c[i] == 0)
1335                                 {
1336                                 dsa_c[i][0]=1;
1337                                 dsa_c[i][1]=1;
1338                                 }
1339                         }
1340                 }
1341 #endif
1342
1343 #ifndef OPENSSL_NO_ECDSA
1344         ecdsa_c[R_EC_P160][0]=count/1000;
1345         ecdsa_c[R_EC_P160][1]=count/1000/2;
1346         for (i=R_EC_P224; i<=R_EC_P521; i++)
1347                 {
1348                 ecdsa_c[i][0]=ecdsa_c[i-1][0]/2;
1349                 ecdsa_c[i][1]=ecdsa_c[i-1][1]/2;
1350                 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1351                         ecdsa_doit[i]=0;
1352                 else
1353                         {
1354                         if (ecdsa_c[i] == 0)
1355                                 {
1356                                 ecdsa_c[i][0]=1;
1357                                 ecdsa_c[i][1]=1;
1358                                 }
1359                         }
1360                 }
1361         ecdsa_c[R_EC_K163][0]=count/1000;
1362         ecdsa_c[R_EC_K163][1]=count/1000/2;
1363         for (i=R_EC_K233; i<=R_EC_K571; i++)
1364                 {
1365                 ecdsa_c[i][0]=ecdsa_c[i-1][0]/2;
1366                 ecdsa_c[i][1]=ecdsa_c[i-1][1]/2;
1367                 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1368                         ecdsa_doit[i]=0;
1369                 else
1370                         {
1371                         if (ecdsa_c[i] == 0)
1372                                 {
1373                                 ecdsa_c[i][0]=1;
1374                                 ecdsa_c[i][1]=1;
1375                                 }
1376                         }
1377                 }
1378         ecdsa_c[R_EC_B163][0]=count/1000;
1379         ecdsa_c[R_EC_B163][1]=count/1000/2;
1380         for (i=R_EC_B233; i<=R_EC_B571; i++)
1381                 {
1382                 ecdsa_c[i][0]=ecdsa_c[i-1][0]/2;
1383                 ecdsa_c[i][1]=ecdsa_c[i-1][1]/2;
1384                 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1385                         ecdsa_doit[i]=0;
1386                 else
1387                         {
1388                         if (ecdsa_c[i] == 0)
1389                                 {
1390                                 ecdsa_c[i][0]=1;
1391                                 ecdsa_c[i][1]=1;
1392                                 }
1393                         }
1394                 }
1395 #endif
1396
1397 #ifndef OPENSSL_NO_ECDH
1398         ecdh_c[R_EC_P160][0]=count/1000;
1399         ecdh_c[R_EC_P160][1]=count/1000;
1400         for (i=R_EC_P224; i<=R_EC_P521; i++)
1401                 {
1402                 ecdh_c[i][0]=ecdh_c[i-1][0]/2;
1403                 ecdh_c[i][1]=ecdh_c[i-1][1]/2;
1404                 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1405                         ecdh_doit[i]=0;
1406                 else
1407                         {
1408                         if (ecdh_c[i] == 0)
1409                                 {
1410                                 ecdh_c[i][0]=1;
1411                                 ecdh_c[i][1]=1;
1412                                 }
1413                         }
1414                 }
1415         ecdh_c[R_EC_K163][0]=count/1000;
1416         ecdh_c[R_EC_K163][1]=count/1000;
1417         for (i=R_EC_K233; i<=R_EC_K571; i++)
1418                 {
1419                 ecdh_c[i][0]=ecdh_c[i-1][0]/2;
1420                 ecdh_c[i][1]=ecdh_c[i-1][1]/2;
1421                 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1422                         ecdh_doit[i]=0;
1423                 else
1424                         {
1425                         if (ecdh_c[i] == 0)
1426                                 {
1427                                 ecdh_c[i][0]=1;
1428                                 ecdh_c[i][1]=1;
1429                                 }
1430                         }
1431                 }
1432         ecdh_c[R_EC_B163][0]=count/1000;
1433         ecdh_c[R_EC_B163][1]=count/1000;
1434         for (i=R_EC_B233; i<=R_EC_B571; i++)
1435                 {
1436                 ecdh_c[i][0]=ecdh_c[i-1][0]/2;
1437                 ecdh_c[i][1]=ecdh_c[i-1][1]/2;
1438                 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1439                         ecdh_doit[i]=0;
1440                 else
1441                         {
1442                         if (ecdh_c[i] == 0)
1443                                 {
1444                                 ecdh_c[i][0]=1;
1445                                 ecdh_c[i][1]=1;
1446                                 }
1447                         }
1448                 }
1449 #endif
1450
1451 #define COND(d) (count < (d))
1452 #define COUNT(d) (d)
1453 #else
1454 /* not worth fixing */
1455 # error "You cannot disable DES on systems without SIGALRM."
1456 #endif /* OPENSSL_NO_DES */
1457 #else
1458 #define COND(c) (run)
1459 #define COUNT(d) (count)
1460         signal(SIGALRM,sig_done);
1461 #endif /* SIGALRM */
1462
1463 #ifndef OPENSSL_NO_MD2
1464         if (doit[D_MD2])
1465                 {
1466                 for (j=0; j<SIZE_NUM; j++)
1467                         {
1468                         print_message(names[D_MD2],c[D_MD2][j],lengths[j]);
1469                         Time_F(START);
1470                         for (count=0,run=1; COND(c[D_MD2][j]); count++)
1471                                 EVP_Digest(buf,(unsigned long)lengths[j],&(md2[0]),NULL,EVP_md2(),NULL);
1472                         d=Time_F(STOP);
1473                         print_result(D_MD2,j,count,d);
1474                         }
1475                 }
1476 #endif
1477 #ifndef OPENSSL_NO_MDC2
1478         if (doit[D_MDC2])
1479                 {
1480                 for (j=0; j<SIZE_NUM; j++)
1481                         {
1482                         print_message(names[D_MDC2],c[D_MDC2][j],lengths[j]);
1483                         Time_F(START);
1484                         for (count=0,run=1; COND(c[D_MDC2][j]); count++)
1485                                 EVP_Digest(buf,(unsigned long)lengths[j],&(mdc2[0]),NULL,EVP_mdc2(),NULL);
1486                         d=Time_F(STOP);
1487                         print_result(D_MDC2,j,count,d);
1488                         }
1489                 }
1490 #endif
1491
1492 #ifndef OPENSSL_NO_MD4
1493         if (doit[D_MD4])
1494                 {
1495                 for (j=0; j<SIZE_NUM; j++)
1496                         {
1497                         print_message(names[D_MD4],c[D_MD4][j],lengths[j]);
1498                         Time_F(START);
1499                         for (count=0,run=1; COND(c[D_MD4][j]); count++)
1500                                 EVP_Digest(&(buf[0]),(unsigned long)lengths[j],&(md4[0]),NULL,EVP_md4(),NULL);
1501                         d=Time_F(STOP);
1502                         print_result(D_MD4,j,count,d);
1503                         }
1504                 }
1505 #endif
1506
1507 #ifndef OPENSSL_NO_MD5
1508         if (doit[D_MD5])
1509                 {
1510                 for (j=0; j<SIZE_NUM; j++)
1511                         {
1512                         print_message(names[D_MD5],c[D_MD5][j],lengths[j]);
1513                         Time_F(START);
1514                         for (count=0,run=1; COND(c[D_MD5][j]); count++)
1515                                 EVP_Digest(&(buf[0]),(unsigned long)lengths[j],&(md5[0]),NULL,EVP_get_digestbyname("md5"),NULL);
1516                         d=Time_F(STOP);
1517                         print_result(D_MD5,j,count,d);
1518                         }
1519                 }
1520 #endif
1521
1522 #if !defined(OPENSSL_NO_MD5) && !defined(OPENSSL_NO_HMAC)
1523         if (doit[D_HMAC])
1524                 {
1525                 HMAC_CTX hctx;
1526
1527                 HMAC_CTX_init(&hctx);
1528                 HMAC_Init_ex(&hctx,(unsigned char *)"This is a key...",
1529                         16,EVP_md5(), NULL);
1530
1531                 for (j=0; j<SIZE_NUM; j++)
1532                         {
1533                         print_message(names[D_HMAC],c[D_HMAC][j],lengths[j]);
1534                         Time_F(START);
1535                         for (count=0,run=1; COND(c[D_HMAC][j]); count++)
1536                                 {
1537                                 HMAC_Init_ex(&hctx,NULL,0,NULL,NULL);
1538                                 HMAC_Update(&hctx,buf,lengths[j]);
1539                                 HMAC_Final(&hctx,&(hmac[0]),NULL);
1540                                 }
1541                         d=Time_F(STOP);
1542                         print_result(D_HMAC,j,count,d);
1543                         }
1544                 HMAC_CTX_cleanup(&hctx);
1545                 }
1546 #endif
1547 #ifndef OPENSSL_NO_SHA
1548         if (doit[D_SHA1])
1549                 {
1550                 for (j=0; j<SIZE_NUM; j++)
1551                         {
1552                         print_message(names[D_SHA1],c[D_SHA1][j],lengths[j]);
1553                         Time_F(START);
1554                         for (count=0,run=1; COND(c[D_SHA1][j]); count++)
1555                                 EVP_Digest(buf,(unsigned long)lengths[j],&(sha[0]),NULL,EVP_sha1(),NULL);
1556                         d=Time_F(STOP);
1557                         print_result(D_SHA1,j,count,d);
1558                         }
1559                 }
1560 #endif
1561 #ifndef OPENSSL_NO_RIPEMD
1562         if (doit[D_RMD160])
1563                 {
1564                 for (j=0; j<SIZE_NUM; j++)
1565                         {
1566                         print_message(names[D_RMD160],c[D_RMD160][j],lengths[j]);
1567                         Time_F(START);
1568                         for (count=0,run=1; COND(c[D_RMD160][j]); count++)
1569                                 EVP_Digest(buf,(unsigned long)lengths[j],&(rmd160[0]),NULL,EVP_ripemd160(),NULL);
1570                         d=Time_F(STOP);
1571                         print_result(D_RMD160,j,count,d);
1572                         }
1573                 }
1574 #endif
1575 #ifndef OPENSSL_NO_RC4
1576         if (doit[D_RC4])
1577                 {
1578                 for (j=0; j<SIZE_NUM; j++)
1579                         {
1580                         print_message(names[D_RC4],c[D_RC4][j],lengths[j]);
1581                         Time_F(START);
1582                         for (count=0,run=1; COND(c[D_RC4][j]); count++)
1583                                 RC4(&rc4_ks,(unsigned int)lengths[j],
1584                                         buf,buf);
1585                         d=Time_F(STOP);
1586                         print_result(D_RC4,j,count,d);
1587                         }
1588                 }
1589 #endif
1590 #ifndef OPENSSL_NO_DES
1591         if (doit[D_CBC_DES])
1592                 {
1593                 for (j=0; j<SIZE_NUM; j++)
1594                         {
1595                         print_message(names[D_CBC_DES],c[D_CBC_DES][j],lengths[j]);
1596                         Time_F(START);
1597                         for (count=0,run=1; COND(c[D_CBC_DES][j]); count++)
1598                                 DES_ncbc_encrypt(buf,buf,lengths[j],&sch,
1599                                                  &DES_iv,DES_ENCRYPT);
1600                         d=Time_F(STOP);
1601                         print_result(D_CBC_DES,j,count,d);
1602                         }
1603                 }
1604
1605         if (doit[D_EDE3_DES])
1606                 {
1607                 for (j=0; j<SIZE_NUM; j++)
1608                         {
1609                         print_message(names[D_EDE3_DES],c[D_EDE3_DES][j],lengths[j]);
1610                         Time_F(START);
1611                         for (count=0,run=1; COND(c[D_EDE3_DES][j]); count++)
1612                                 DES_ede3_cbc_encrypt(buf,buf,lengths[j],
1613                                                      &sch,&sch2,&sch3,
1614                                                      &DES_iv,DES_ENCRYPT);
1615                         d=Time_F(STOP);
1616                         print_result(D_EDE3_DES,j,count,d);
1617                         }
1618                 }
1619 #endif
1620 #ifndef OPENSSL_NO_AES
1621         if (doit[D_CBC_128_AES])
1622                 {
1623                 for (j=0; j<SIZE_NUM; j++)
1624                         {
1625                         print_message(names[D_CBC_128_AES],c[D_CBC_128_AES][j],lengths[j]);
1626                         Time_F(START);
1627                         for (count=0,run=1; COND(c[D_CBC_128_AES][j]); count++)
1628                                 AES_cbc_encrypt(buf,buf,
1629                                         (unsigned long)lengths[j],&aes_ks1,
1630                                         iv,AES_ENCRYPT);
1631                         d=Time_F(STOP);
1632                         print_result(D_CBC_128_AES,j,count,d);
1633                         }
1634                 }
1635         if (doit[D_CBC_192_AES])
1636                 {
1637                 for (j=0; j<SIZE_NUM; j++)
1638                         {
1639                         print_message(names[D_CBC_192_AES],c[D_CBC_192_AES][j],lengths[j]);
1640                         Time_F(START);
1641                         for (count=0,run=1; COND(c[D_CBC_192_AES][j]); count++)
1642                                 AES_cbc_encrypt(buf,buf,
1643                                         (unsigned long)lengths[j],&aes_ks2,
1644                                         iv,AES_ENCRYPT);
1645                         d=Time_F(STOP);
1646                         print_result(D_CBC_192_AES,j,count,d);
1647                         }
1648                 }
1649         if (doit[D_CBC_256_AES])
1650                 {
1651                 for (j=0; j<SIZE_NUM; j++)
1652                         {
1653                         print_message(names[D_CBC_256_AES],c[D_CBC_256_AES][j],lengths[j]);
1654                         Time_F(START);
1655                         for (count=0,run=1; COND(c[D_CBC_256_AES][j]); count++)
1656                                 AES_cbc_encrypt(buf,buf,
1657                                         (unsigned long)lengths[j],&aes_ks3,
1658                                         iv,AES_ENCRYPT);
1659                         d=Time_F(STOP);
1660                         print_result(D_CBC_256_AES,j,count,d);
1661                         }
1662                 }
1663
1664 #endif
1665 #ifndef OPENSSL_NO_IDEA
1666         if (doit[D_CBC_IDEA])
1667                 {
1668                 for (j=0; j<SIZE_NUM; j++)
1669                         {
1670                         print_message(names[D_CBC_IDEA],c[D_CBC_IDEA][j],lengths[j]);
1671                         Time_F(START);
1672                         for (count=0,run=1; COND(c[D_CBC_IDEA][j]); count++)
1673                                 idea_cbc_encrypt(buf,buf,
1674                                         (unsigned long)lengths[j],&idea_ks,
1675                                         iv,IDEA_ENCRYPT);
1676                         d=Time_F(STOP);
1677                         print_result(D_CBC_IDEA,j,count,d);
1678                         }
1679                 }
1680 #endif
1681 #ifndef OPENSSL_NO_RC2
1682         if (doit[D_CBC_RC2])
1683                 {
1684                 for (j=0; j<SIZE_NUM; j++)
1685                         {
1686                         print_message(names[D_CBC_RC2],c[D_CBC_RC2][j],lengths[j]);
1687                         Time_F(START);
1688                         for (count=0,run=1; COND(c[D_CBC_RC2][j]); count++)
1689                                 RC2_cbc_encrypt(buf,buf,
1690                                         (unsigned long)lengths[j],&rc2_ks,
1691                                         iv,RC2_ENCRYPT);
1692                         d=Time_F(STOP);
1693                         print_result(D_CBC_RC2,j,count,d);
1694                         }
1695                 }
1696 #endif
1697 #ifndef OPENSSL_NO_RC5
1698         if (doit[D_CBC_RC5])
1699                 {
1700                 for (j=0; j<SIZE_NUM; j++)
1701                         {
1702                         print_message(names[D_CBC_RC5],c[D_CBC_RC5][j],lengths[j]);
1703                         Time_F(START);
1704                         for (count=0,run=1; COND(c[D_CBC_RC5][j]); count++)
1705                                 RC5_32_cbc_encrypt(buf,buf,
1706                                         (unsigned long)lengths[j],&rc5_ks,
1707                                         iv,RC5_ENCRYPT);
1708                         d=Time_F(STOP);
1709                         print_result(D_CBC_RC5,j,count,d);
1710                         }
1711                 }
1712 #endif
1713 #ifndef OPENSSL_NO_BF
1714         if (doit[D_CBC_BF])
1715                 {
1716                 for (j=0; j<SIZE_NUM; j++)
1717                         {
1718                         print_message(names[D_CBC_BF],c[D_CBC_BF][j],lengths[j]);
1719                         Time_F(START);
1720                         for (count=0,run=1; COND(c[D_CBC_BF][j]); count++)
1721                                 BF_cbc_encrypt(buf,buf,
1722                                         (unsigned long)lengths[j],&bf_ks,
1723                                         iv,BF_ENCRYPT);
1724                         d=Time_F(STOP);
1725                         print_result(D_CBC_BF,j,count,d);
1726                         }
1727                 }
1728 #endif
1729 #ifndef OPENSSL_NO_CAST
1730         if (doit[D_CBC_CAST])
1731                 {
1732                 for (j=0; j<SIZE_NUM; j++)
1733                         {
1734                         print_message(names[D_CBC_CAST],c[D_CBC_CAST][j],lengths[j]);
1735                         Time_F(START);
1736                         for (count=0,run=1; COND(c[D_CBC_CAST][j]); count++)
1737                                 CAST_cbc_encrypt(buf,buf,
1738                                         (unsigned long)lengths[j],&cast_ks,
1739                                         iv,CAST_ENCRYPT);
1740                         d=Time_F(STOP);
1741                         print_result(D_CBC_CAST,j,count,d);
1742                         }
1743                 }
1744 #endif
1745
1746         if (doit[D_EVP])
1747                 {
1748                 for (j=0; j<SIZE_NUM; j++)
1749                         {
1750                         if (evp_cipher)
1751                                 {
1752                                 EVP_CIPHER_CTX ctx;
1753                                 int outl;
1754
1755                                 names[D_EVP]=OBJ_nid2ln(evp_cipher->nid);
1756                                 /* -O3 -fschedule-insns messes up an
1757                                  * optimization here!  names[D_EVP]
1758                                  * somehow becomes NULL */
1759                                 print_message(names[D_EVP],save_count,
1760                                         lengths[j]);
1761
1762                                 EVP_CIPHER_CTX_init(&ctx);
1763                                 if(decrypt)
1764                                         EVP_DecryptInit_ex(&ctx,evp_cipher,NULL,key16,iv);
1765                                 else
1766                                         EVP_EncryptInit_ex(&ctx,evp_cipher,NULL,key16,iv);
1767
1768                                 Time_F(START);
1769                                 if(decrypt)
1770                                         for (count=0,run=1; COND(save_count*4*lengths[0]/lengths[j]); count++)
1771                                                 EVP_DecryptUpdate(&ctx,buf,&outl,buf,lengths[j]);
1772                                 else
1773                                         for (count=0,run=1; COND(save_count*4*lengths[0]/lengths[j]); count++)
1774                                                 EVP_EncryptUpdate(&ctx,buf,&outl,buf,lengths[j]);
1775                                 if(decrypt)
1776                                         EVP_DecryptFinal_ex(&ctx,buf,&outl);
1777                                 else
1778                                         EVP_EncryptFinal_ex(&ctx,buf,&outl);
1779                                 d=Time_F(STOP);
1780                                 EVP_CIPHER_CTX_cleanup(&ctx);
1781                                 }
1782                         if (evp_md)
1783                                 {
1784                                 names[D_EVP]=OBJ_nid2ln(evp_md->type);
1785                                 print_message(names[D_EVP],save_count,
1786                                         lengths[j]);
1787
1788                                 Time_F(START);
1789                                 for (count=0,run=1; COND(save_count*4*lengths[0]/lengths[j]); count++)
1790                                         EVP_Digest(buf,lengths[j],&(md[0]),NULL,evp_md,NULL);
1791
1792                                 d=Time_F(STOP);
1793                                 }
1794                         print_result(D_EVP,j,count,d);
1795                         }
1796                 }
1797
1798         RAND_pseudo_bytes(buf,36);
1799 #ifndef OPENSSL_NO_RSA
1800         for (j=0; j<RSA_NUM; j++)
1801                 {
1802                 int ret;
1803                 if (!rsa_doit[j]) continue;
1804                 ret=RSA_sign(NID_md5_sha1, buf,36, buf2, &rsa_num, rsa_key[j]);
1805                 if (ret == 0)
1806                         {
1807                         BIO_printf(bio_err,"RSA sign failure.  No RSA sign will be done.\n");
1808                         ERR_print_errors(bio_err);
1809                         rsa_count=1;
1810                         }
1811                 else
1812                         {
1813                         pkey_print_message("private","rsa",
1814                                 rsa_c[j][0],rsa_bits[j],
1815                                 RSA_SECONDS);
1816 /*                      RSA_blinding_on(rsa_key[j],NULL); */
1817                         Time_F(START);
1818                         for (count=0,run=1; COND(rsa_c[j][0]); count++)
1819                                 {
1820                                 ret=RSA_sign(NID_md5_sha1, buf,36, buf2,
1821                                         &rsa_num, rsa_key[j]);
1822                                 if (ret == 0)
1823                                         {
1824                                         BIO_printf(bio_err,
1825                                                 "RSA sign failure\n");
1826                                         ERR_print_errors(bio_err);
1827                                         count=1;
1828                                         break;
1829                                         }
1830                                 }
1831                         d=Time_F(STOP);
1832                         BIO_printf(bio_err,mr ? "+R1:%ld:%d:%.2f\n"
1833                                    : "%ld %d bit private RSA's in %.2fs\n",
1834                                    count,rsa_bits[j],d);
1835                         rsa_results[j][0]=d/(double)count;
1836                         rsa_count=count;
1837                         }
1838
1839 #if 1
1840                 ret=RSA_verify(NID_md5_sha1, buf,36, buf2, rsa_num, rsa_key[j]);
1841                 if (ret <= 0)
1842                         {
1843                         BIO_printf(bio_err,"RSA verify failure.  No RSA verify will be done.\n");
1844                         ERR_print_errors(bio_err);
1845                         rsa_doit[j] = 0;
1846                         }
1847                 else
1848                         {
1849                         pkey_print_message("public","rsa",
1850                                 rsa_c[j][1],rsa_bits[j],
1851                                 RSA_SECONDS);
1852                         Time_F(START);
1853                         for (count=0,run=1; COND(rsa_c[j][1]); count++)
1854                                 {
1855                                 ret=RSA_verify(NID_md5_sha1, buf,36, buf2,
1856                                         rsa_num, rsa_key[j]);
1857                                 if (ret == 0)
1858                                         {
1859                                         BIO_printf(bio_err,
1860                                                 "RSA verify failure\n");
1861                                         ERR_print_errors(bio_err);
1862                                         count=1;
1863                                         break;
1864                                         }
1865                                 }
1866                         d=Time_F(STOP);
1867                         BIO_printf(bio_err,mr ? "+R2:%ld:%d:%.2f\n"
1868                                    : "%ld %d bit public RSA's in %.2fs\n",
1869                                    count,rsa_bits[j],d);
1870                         rsa_results[j][1]=d/(double)count;
1871                         }
1872 #endif
1873
1874                 if (rsa_count <= 1)
1875                         {
1876                         /* if longer than 10s, don't do any more */
1877                         for (j++; j<RSA_NUM; j++)
1878                                 rsa_doit[j]=0;
1879                         }
1880                 }
1881 #endif
1882
1883         RAND_pseudo_bytes(buf,20);
1884 #ifndef OPENSSL_NO_DSA
1885         if (RAND_status() != 1)
1886                 {
1887                 RAND_seed(rnd_seed, sizeof rnd_seed);
1888                 rnd_fake = 1;
1889                 }
1890         for (j=0; j<DSA_NUM; j++)
1891                 {
1892                 unsigned int kk;
1893                 int ret;
1894
1895                 if (!dsa_doit[j]) continue;
1896 /*              DSA_generate_key(dsa_key[j]); */
1897 /*              DSA_sign_setup(dsa_key[j],NULL); */
1898                 ret=DSA_sign(EVP_PKEY_DSA,buf,20,buf2,
1899                         &kk,dsa_key[j]);
1900                 if (ret == 0)
1901                         {
1902                         BIO_printf(bio_err,"DSA sign failure.  No DSA sign will be done.\n");
1903                         ERR_print_errors(bio_err);
1904                         rsa_count=1;
1905                         }
1906                 else
1907                         {
1908                         pkey_print_message("sign","dsa",
1909                                 dsa_c[j][0],dsa_bits[j],
1910                                 DSA_SECONDS);
1911                         Time_F(START);
1912                         for (count=0,run=1; COND(dsa_c[j][0]); count++)
1913                                 {
1914                                 ret=DSA_sign(EVP_PKEY_DSA,buf,20,buf2,
1915                                         &kk,dsa_key[j]);
1916                                 if (ret == 0)
1917                                         {
1918                                         BIO_printf(bio_err,
1919                                                 "DSA sign failure\n");
1920                                         ERR_print_errors(bio_err);
1921                                         count=1;
1922                                         break;
1923                                         }
1924                                 }
1925                         d=Time_F(STOP);
1926                         BIO_printf(bio_err,mr ? "+R3:%ld:%d:%.2f\n"
1927                                    : "%ld %d bit DSA signs in %.2fs\n",
1928                                    count,dsa_bits[j],d);
1929                         dsa_results[j][0]=d/(double)count;
1930                         rsa_count=count;
1931                         }
1932
1933                 ret=DSA_verify(EVP_PKEY_DSA,buf,20,buf2,
1934                         kk,dsa_key[j]);
1935                 if (ret <= 0)
1936                         {
1937                         BIO_printf(bio_err,"DSA verify failure.  No DSA verify will be done.\n");
1938                         ERR_print_errors(bio_err);
1939                         dsa_doit[j] = 0;
1940                         }
1941                 else
1942                         {
1943                         pkey_print_message("verify","dsa",
1944                                 dsa_c[j][1],dsa_bits[j],
1945                                 DSA_SECONDS);
1946                         Time_F(START);
1947                         for (count=0,run=1; COND(dsa_c[j][1]); count++)
1948                                 {
1949                                 ret=DSA_verify(EVP_PKEY_DSA,buf,20,buf2,
1950                                         kk,dsa_key[j]);
1951                                 if (ret <= 0)
1952                                         {
1953                                         BIO_printf(bio_err,
1954                                                 "DSA verify failure\n");
1955                                         ERR_print_errors(bio_err);
1956                                         count=1;
1957                                         break;
1958                                         }
1959                                 }
1960                         d=Time_F(STOP);
1961                         BIO_printf(bio_err,mr ? "+R4:%ld:%d:%.2f\n"
1962                                    : "%ld %d bit DSA verify in %.2fs\n",
1963                                    count,dsa_bits[j],d);
1964                         dsa_results[j][1]=d/(double)count;
1965                         }
1966
1967                 if (rsa_count <= 1)
1968                         {
1969                         /* if longer than 10s, don't do any more */
1970                         for (j++; j<DSA_NUM; j++)
1971                                 dsa_doit[j]=0;
1972                         }
1973                 }
1974         if (rnd_fake) RAND_cleanup();
1975 #endif
1976
1977 #ifndef OPENSSL_NO_ECDSA
1978         if (RAND_status() != 1)
1979                 {
1980                 RAND_seed(rnd_seed, sizeof rnd_seed);
1981                 rnd_fake = 1;
1982                 }
1983         for (j=0; j<EC_NUM; j++)
1984                 {
1985                 int ret;
1986
1987                 if (!ecdsa_doit[j]) continue; /* Ignore Curve */
1988                 ecdsa[j] = EC_KEY_new();
1989                 if (ecdsa[j] == NULL)
1990                         {
1991                         BIO_printf(bio_err,"ECDSA failure.\n");
1992                         ERR_print_errors(bio_err);
1993                         rsa_count=1;
1994                         }
1995                 else
1996                         {
1997                         ecdsa[j]->group = EC_GROUP_new_by_nid(test_curves[j]);
1998                         /* Could not obtain group information */
1999                         if (ecdsa[j]->group == NULL)
2000                                 {
2001                                 BIO_printf(bio_err,"ECDSA failure.Could not obtain group information\n");
2002                                 ERR_print_errors(bio_err);
2003                                 rsa_count=1;
2004                                 }
2005                         else
2006                                 {
2007 #if 1
2008                                 EC_GROUP_precompute_mult(ecdsa[j]->group, NULL);
2009 #endif
2010                                 /* Perform ECDSA signature test */
2011                                 EC_KEY_generate_key(ecdsa[j]);
2012                                 ret = ECDSA_sign(0, buf, 20, ecdsasig,
2013                                         &ecdsasiglen, ecdsa[j]);
2014                                 if (ret == 0)
2015                                         {
2016                                         BIO_printf(bio_err,"ECDSA sign failure.  No ECDSA sign will be done.\n");
2017                                         ERR_print_errors(bio_err);
2018                                         rsa_count=1;
2019                                         }
2020                                 else
2021                                         {
2022                                         pkey_print_message("sign","ecdsa",
2023                                                 ecdsa_c[j][0],
2024                                                 test_curves_bits[j],
2025                                                 ECDSA_SECONDS);
2026
2027                                         Time_F(START);
2028                                         for (count=0,run=1; COND(ecdsa_c[j][0]);
2029                                                 count++)
2030                                                 {
2031                                                 ret=ECDSA_sign(0, buf, 20,
2032                                                         ecdsasig, &ecdsasiglen,
2033                                                         ecdsa[j]);
2034                                                 if (ret == 0)
2035                                                         {
2036                                                         BIO_printf(bio_err, "ECDSA sign failure\n");
2037                                                         ERR_print_errors(bio_err);
2038                                                         count=1;
2039                                                         break;
2040                                                         }
2041                                                 }
2042                                                 d=Time_F(STOP);
2043
2044                                                 BIO_printf(bio_err, mr ? "+R5:%ld:%d:%.2f\n" :
2045                                                 "%ld %d bit ECDSA signs in %.2fs \n",
2046                                                 count, test_curves_bits[j], d);
2047                                                 ecdsa_results[j][0]=d/(double)count;
2048                                                 rsa_count=count;
2049                                         }
2050
2051                                 /* Perform ECDSA verification test */
2052                                 ret=ECDSA_verify(0, buf, 20, ecdsasig,
2053                                         ecdsasiglen, ecdsa[j]);
2054                                 if (ret != 1)
2055                                         {
2056                                         BIO_printf(bio_err,"ECDSA verify failure.  No ECDSA verify will be done.\n");
2057                                         ERR_print_errors(bio_err);
2058                                         ecdsa_doit[j] = 0;
2059                                         }
2060                                 else
2061                                         {
2062                                         pkey_print_message("verify","ecdsa",
2063                                         ecdsa_c[j][1],
2064                                         test_curves_bits[j],
2065                                         ECDSA_SECONDS);
2066                                         Time_F(START);
2067                                         for (count=0,run=1; COND(ecdsa_c[j][1]); count++)
2068                                                 {
2069                                                 ret=ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[j]);
2070                                                 if (ret != 1)
2071                                                         {
2072                                                         BIO_printf(bio_err, "ECDSA verify failure\n");
2073                                                         ERR_print_errors(bio_err);
2074                                                         count=1;
2075                                                         break;
2076                                                         }
2077                                                 }
2078                                                 d=Time_F(STOP);
2079                                                 BIO_printf(bio_err, mr? "+R6:%ld:%d:%.2f\n"
2080                                                         : "%ld %d bit ECDSA verify in %.2fs\n",
2081                                                 count, test_curves_bits[j], d);
2082                                                 ecdsa_results[j][1]=d/(double)count;
2083                                         }
2084
2085                                 if (rsa_count <= 1)
2086                                         {
2087                                         /* if longer than 10s, don't do any more */
2088                                         for (j++; j<EC_NUM; j++)
2089                                         ecdsa_doit[j]=0;
2090                                         }
2091                                 }
2092                         }
2093                 }
2094         if (rnd_fake) RAND_cleanup();
2095 #endif
2096
2097 #ifndef OPENSSL_NO_ECDH
2098         if (RAND_status() != 1)
2099                 {
2100                 RAND_seed(rnd_seed, sizeof rnd_seed);
2101                 rnd_fake = 1;
2102                 }
2103         for (j=0; j<EC_NUM; j++)
2104                 {
2105                 if (!ecdh_doit[j]) continue;
2106                 ecdh_a[j] = EC_KEY_new();
2107                 ecdh_b[j] = EC_KEY_new();
2108                 if ((ecdh_a[j] == NULL) || (ecdh_b[j] == NULL))
2109                         {
2110                         BIO_printf(bio_err,"ECDH failure.\n");
2111                         ERR_print_errors(bio_err);
2112                         rsa_count=1;
2113                         }
2114                 else
2115                         {
2116                         ecdh_a[j]->group = EC_GROUP_new_by_nid(test_curves[j]);
2117                         if (ecdh_a[j]->group == NULL)
2118                                 {
2119                                 BIO_printf(bio_err,"ECDH failure.\n");
2120                                 ERR_print_errors(bio_err);
2121                                 rsa_count=1;
2122                                 }
2123                         else
2124                                 {
2125                                 ecdh_b[j]->group = EC_GROUP_dup(ecdh_a[j]->group);
2126
2127                                 /* generate two ECDH key pairs */
2128                                 if (!EC_KEY_generate_key(ecdh_a[j]) ||
2129                                         !EC_KEY_generate_key(ecdh_b[j]))
2130                                         {
2131                                         BIO_printf(bio_err,"ECDH key generation failure.\n");
2132                                         ERR_print_errors(bio_err);
2133                                         rsa_count=1;
2134                                         }
2135                                 else
2136                                         {
2137                                         /* If field size is not more than 24 octets, then use SHA-1 hash of result;
2138                                          * otherwise, use result (see section 4.8 of draft-ietf-tls-ecc-03.txt).
2139                                          */
2140                                         int field_size, outlen;
2141                                         void *(*kdf)(void *in, size_t inlen, void *out, size_t xoutlen);
2142                                         field_size = EC_GROUP_get_degree(ecdh_a[j]->group);
2143                                         if (field_size <= 24 * 8)
2144                                                 {
2145                                                 outlen = KDF1_SHA1_len;
2146                                                 kdf = KDF1_SHA1;
2147                                                 }
2148                                         else
2149                                                 {
2150                                                 outlen = (field_size+7)/8;
2151                                                 kdf = NULL;
2152                                                 }
2153                                         secret_size_a = ECDH_compute_key(secret_a, outlen,
2154                                                 ecdh_b[j]->pub_key,
2155                                                 ecdh_a[j], kdf);
2156                                         secret_size_b = ECDH_compute_key(secret_b, outlen,
2157                                                 ecdh_a[j]->pub_key,
2158                                                 ecdh_b[j], kdf);
2159                                         if (secret_size_a != secret_size_b)
2160                                                 ecdh_checks = 0;
2161                                         else
2162                                                 ecdh_checks = 1;
2163
2164                                         for (secret_idx = 0;
2165                                             (secret_idx < secret_size_a)
2166                                                 && (ecdh_checks == 1);
2167                                             secret_idx++)
2168                                                 {
2169                                                 if (secret_a[secret_idx] != secret_b[secret_idx])
2170                                                 ecdh_checks = 0;
2171                                                 }
2172
2173                                         if (ecdh_checks == 0)
2174                                                 {
2175                                                 BIO_printf(bio_err,"ECDH computations don't match.\n");
2176                                                 ERR_print_errors(bio_err);
2177                                                 rsa_count=1;
2178                                                 }
2179
2180                                         pkey_print_message("","ecdh",
2181                                         ecdh_c[j][0],
2182                                         test_curves_bits[j],
2183                                         ECDH_SECONDS);
2184                                         Time_F(START);
2185                                         for (count=0,run=1; COND(ecdh_c[j][0]); count++)
2186                                                 {
2187                                                 ECDH_compute_key(secret_a, outlen,
2188                                                 ecdh_b[j]->pub_key,
2189                                                 ecdh_a[j], kdf);
2190                                                 }
2191                                         d=Time_F(STOP);
2192                                         BIO_printf(bio_err, mr ? "+R7:%ld:%d:%.2f\n" :"%ld %d-bit ECDH ops in %.2fs\n",
2193                                         count, test_curves_bits[j], d);
2194                                         ecdh_results[j][0]=d/(double)count;
2195                                         rsa_count=count;
2196                                         }
2197                                 }
2198                         }
2199
2200                 if (rsa_count <= 1)
2201                         {
2202                         /* if longer than 10s, don't do any more */
2203                         for (j++; j<EC_NUM; j++)
2204                         ecdh_doit[j]=0;
2205                         }
2206                 }
2207         if (rnd_fake) RAND_cleanup();
2208 #endif
2209 #ifdef HAVE_FORK
2210 show_res:
2211 #endif
2212         if(!mr)
2213                 {
2214                 fprintf(stdout,"%s\n",SSLeay_version(SSLEAY_VERSION));
2215         fprintf(stdout,"%s\n",SSLeay_version(SSLEAY_BUILT_ON));
2216                 printf("options:");
2217                 printf("%s ",BN_options());
2218 #ifndef OPENSSL_NO_MD2
2219                 printf("%s ",MD2_options());
2220 #endif
2221 #ifndef OPENSSL_NO_RC4
2222                 printf("%s ",RC4_options());
2223 #endif
2224 #ifndef OPENSSL_NO_DES
2225                 printf("%s ",DES_options());
2226 #endif
2227 #ifndef OPENSSL_NO_AES
2228                 printf("%s ",AES_options());
2229 #endif
2230 #ifndef OPENSSL_NO_IDEA
2231                 printf("%s ",idea_options());
2232 #endif
2233 #ifndef OPENSSL_NO_BF
2234                 printf("%s ",BF_options());
2235 #endif
2236                 fprintf(stdout,"\n%s\n",SSLeay_version(SSLEAY_CFLAGS));
2237                 printf("available timing options: ");
2238 #ifdef TIMES
2239                 printf("TIMES ");
2240 #endif
2241 #ifdef TIMEB
2242                 printf("TIMEB ");
2243 #endif
2244 #ifdef USE_TOD
2245                 printf("USE_TOD ");
2246 #endif
2247 #ifdef HZ
2248 #define as_string(s) (#s)
2249                 {
2250                 double dbl = HZ;
2251                 printf("HZ=%g", dbl);
2252                 }
2253 # ifdef _SC_CLK_TCK
2254                 printf(" [sysconf value]");
2255 # endif
2256 #endif
2257                 printf("\n");
2258                 printf("timing function used: %s%s%s%s%s%s%s\n",
2259                        (ftime_used ? "ftime" : ""),
2260                        (ftime_used + times_used > 1 ? "," : ""),
2261                        (times_used ? "times" : ""),
2262                        (ftime_used + times_used + gettimeofday_used > 1 ? "," : ""),
2263                        (gettimeofday_used ? "gettimeofday" : ""),
2264                        (ftime_used + times_used + gettimeofday_used + getrusage_used > 1 ? "," : ""),
2265                        (getrusage_used ? "getrusage" : ""));
2266                 }
2267
2268         if (pr_header)
2269                 {
2270                 if(mr)
2271                         fprintf(stdout,"+H");
2272                 else
2273                         {
2274                         fprintf(stdout,"The 'numbers' are in 1000s of bytes per second processed.\n");
2275                         fprintf(stdout,"type        ");
2276                         }
2277                 for (j=0;  j<SIZE_NUM; j++)
2278                         fprintf(stdout,mr ? ":%d" : "%7d bytes",lengths[j]);
2279                 fprintf(stdout,"\n");
2280                 }
2281
2282         for (k=0; k<ALGOR_NUM; k++)
2283                 {
2284                 if (!doit[k]) continue;
2285                 if(mr)
2286                         fprintf(stdout,"+F:%d:%s",k,names[k]);
2287                 else
2288                         fprintf(stdout,"%-13s",names[k]);
2289                 for (j=0; j<SIZE_NUM; j++)
2290                         {
2291                         if (results[k][j] > 10000 && !mr)
2292                                 fprintf(stdout," %11.2fk",results[k][j]/1e3);
2293                         else
2294                                 fprintf(stdout,mr ? ":%.2f" : " %11.2f ",results[k][j]);
2295                         }
2296                 fprintf(stdout,"\n");
2297                 }
2298 #ifndef OPENSSL_NO_RSA
2299         j=1;
2300         for (k=0; k<RSA_NUM; k++)
2301                 {
2302                 if (!rsa_doit[k]) continue;
2303                 if (j && !mr)
2304                         {
2305                         printf("%18ssign    verify    sign/s verify/s\n"," ");
2306                         j=0;
2307                         }
2308                 if(mr)
2309                         fprintf(stdout,"+F2:%u:%u:%f:%f\n",
2310                                 k,rsa_bits[k],rsa_results[k][0],
2311                                 rsa_results[k][1]);
2312                 else
2313                         fprintf(stdout,"rsa %4u bits %8.4fs %8.4fs %8.1f %8.1f\n",
2314                                 rsa_bits[k],rsa_results[k][0],rsa_results[k][1],
2315                                 1.0/rsa_results[k][0],1.0/rsa_results[k][1]);
2316                 }
2317 #endif
2318 #ifndef OPENSSL_NO_DSA
2319         j=1;
2320         for (k=0; k<DSA_NUM; k++)
2321                 {
2322                 if (!dsa_doit[k]) continue;
2323                 if (j && !mr)
2324                         {
2325                         printf("%18ssign    verify    sign/s verify/s\n"," ");
2326                         j=0;
2327                         }
2328                 if(mr)
2329                         fprintf(stdout,"+F3:%u:%u:%f:%f\n",
2330                                 k,dsa_bits[k],dsa_results[k][0],dsa_results[k][1]);
2331                 else
2332                         fprintf(stdout,"dsa %4u bits %8.4fs %8.4fs %8.1f %8.1f\n",
2333                                 dsa_bits[k],dsa_results[k][0],dsa_results[k][1],
2334                                 1.0/dsa_results[k][0],1.0/dsa_results[k][1]);
2335                 }
2336 #endif
2337 #ifndef OPENSSL_NO_ECDSA
2338         j=1;
2339         for (k=0; k<EC_NUM; k++)
2340                 {
2341                 if (!ecdsa_doit[k]) continue;
2342                 if (j && !mr)
2343                         {
2344                         printf("%30ssign    verify    sign/s verify/s\n"," ");
2345                         j=0;
2346                         }
2347
2348                 if (mr)
2349                         fprintf(stdout,"+F4:%u:%u:%f:%f\n",
2350                                 k, test_curves_bits[k],
2351                                 ecdsa_results[k][0],ecdsa_results[k][1]);
2352                 else
2353                         fprintf(stdout,
2354                                 "%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2355                                 test_curves_bits[k],
2356                                 test_curves_names[k],
2357                                 ecdsa_results[k][0],ecdsa_results[k][1],
2358                                 1.0/ecdsa_results[k][0],1.0/ecdsa_results[k][1]);
2359                 }
2360 #endif
2361
2362
2363 #ifndef OPENSSL_NO_ECDH
2364         j=1;
2365         for (k=0; k<EC_NUM; k++)
2366                 {
2367                 if (!ecdh_doit[k]) continue;
2368                 if (j && !mr)
2369                         {
2370                         printf("%30sop      op/s\n"," ");
2371                         j=0;
2372                         }
2373                 if (mr)
2374                         fprintf(stdout,"+F5:%u:%u:%f:%f\n",
2375                                 k, test_curves_bits[k],
2376                                 ecdh_results[k][0], 1.0/ecdh_results[k][0]);
2377
2378                 else
2379                         fprintf(stdout,"%4u bit ecdh (%s) %8.4fs %8.1f\n",
2380                                 test_curves_bits[k],
2381                                 test_curves_names[k],
2382                                 ecdh_results[k][0], 1.0/ecdh_results[k][0]);
2383                 }
2384 #endif
2385
2386         mret=0;
2387
2388 end:
2389         ERR_print_errors(bio_err);
2390         if (buf != NULL) OPENSSL_free(buf);
2391         if (buf2 != NULL) OPENSSL_free(buf2);
2392 #ifndef OPENSSL_NO_RSA
2393         for (i=0; i<RSA_NUM; i++)
2394                 if (rsa_key[i] != NULL)
2395                         RSA_free(rsa_key[i]);
2396 #endif
2397 #ifndef OPENSSL_NO_DSA
2398         for (i=0; i<DSA_NUM; i++)
2399                 if (dsa_key[i] != NULL)
2400                         DSA_free(dsa_key[i]);
2401 #endif
2402
2403 #ifndef OPENSSL_NO_ECDSA
2404         for (i=0; i<EC_NUM; i++)
2405                 if (ecdsa[i] != NULL)
2406                         EC_KEY_free(ecdsa[i]);
2407 #endif
2408 #ifndef OPENSSL_NO_ECDH
2409         for (i=0; i<EC_NUM; i++)
2410         {
2411                 if (ecdh_a[i] != NULL)
2412                         EC_KEY_free(ecdh_a[i]);
2413                 if (ecdh_b[i] != NULL)
2414                         EC_KEY_free(ecdh_b[i]);
2415         }
2416 #endif
2417
2418         apps_shutdown();
2419         OPENSSL_EXIT(mret);
2420         }
2421
2422 static void print_message(const char *s, long num, int length)
2423         {
2424 #ifdef SIGALRM
2425         BIO_printf(bio_err,mr ? "+DT:%s:%d:%d\n"
2426                    : "Doing %s for %ds on %d size blocks: ",s,SECONDS,length);
2427         (void)BIO_flush(bio_err);
2428         alarm(SECONDS);
2429 #else
2430         BIO_printf(bio_err,mr ? "+DN:%s:%ld:%d\n"
2431                    : "Doing %s %ld times on %d size blocks: ",s,num,length);
2432         (void)BIO_flush(bio_err);
2433 #endif
2434 #ifdef LINT
2435         num=num;
2436 #endif
2437         }
2438
2439 static void pkey_print_message(char *str, char *str2, long num, int bits,
2440              int tm)
2441         {
2442 #ifdef SIGALRM
2443         BIO_printf(bio_err,mr ? "+DTP:%d:%s:%s:%d\n"
2444                            : "Doing %d bit %s %s's for %ds: ",bits,str,str2,tm);
2445         (void)BIO_flush(bio_err);
2446         alarm(RSA_SECONDS);
2447 #else
2448         BIO_printf(bio_err,mr ? "+DNP:%ld:%d:%s:%s\n"
2449                            : "Doing %ld %d bit %s %s's: ",num,bits,str,str2);
2450         (void)BIO_flush(bio_err);
2451 #endif
2452 #ifdef LINT
2453         num=num;
2454 #endif
2455         }
2456
2457 static void print_result(int alg,int run_no,int count,double time_used)
2458         {
2459         BIO_printf(bio_err,mr ? "+R:%d:%s:%f\n"
2460                    : "%d %s's in %.2fs\n",count,names[alg],time_used);
2461         results[alg][run_no]=((double)count)/time_used*lengths[run_no];
2462         }
2463
2464 static char *sstrsep(char **string, const char *delim)
2465     {
2466     char isdelim[256];
2467     char *token = *string;
2468
2469     if (**string == 0)
2470         return NULL;
2471
2472     memset(isdelim, 0, sizeof isdelim);
2473     isdelim[0] = 1;
2474
2475     while (*delim)
2476         {
2477         isdelim[(unsigned char)(*delim)] = 1;
2478         delim++;
2479         }
2480
2481     while (!isdelim[(unsigned char)(**string)])
2482         {
2483         (*string)++;
2484         }
2485
2486     if (**string)
2487         {
2488         **string = 0;
2489         (*string)++;
2490         }
2491
2492     return token;
2493     }
2494
2495 #ifdef HAVE_FORK
2496 static int do_multi(int multi)
2497         {
2498         int n;
2499         int fd[2];
2500         int *fds;
2501         static char sep[]=":";
2502
2503         fds=malloc(multi*sizeof *fds);
2504         for(n=0 ; n < multi ; ++n)
2505                 {
2506                 pipe(fd);
2507                 if(fork())
2508                         {
2509                         close(fd[1]);
2510                         fds[n]=fd[0];
2511                         }
2512                 else
2513                         {
2514                         close(fd[0]);
2515                         close(1);
2516                         dup(fd[1]);
2517                         close(fd[1]);
2518                         mr=1;
2519                         usertime=0;
2520                         return 0;
2521                         }
2522                 printf("Forked child %d\n",n);
2523                 }
2524
2525         /* for now, assume the pipe is long enough to take all the output */
2526         for(n=0 ; n < multi ; ++n)
2527                 {
2528                 FILE *f;
2529                 char buf[1024];
2530                 char *p;
2531
2532                 f=fdopen(fds[n],"r");
2533                 while(fgets(buf,sizeof buf,f))
2534                         {
2535                         p=strchr(buf,'\n');
2536                         if(p)
2537                                 *p='\0';
2538                         if(buf[0] != '+')
2539                                 {
2540                                 fprintf(stderr,"Don't understand line '%s' from child %d\n",
2541                                                 buf,n);
2542                                 continue;
2543                                 }
2544                         printf("Got: %s from %d\n",buf,n);
2545                         if(!strncmp(buf,"+F:",3))
2546                                 {
2547                                 int alg;
2548                                 int j;
2549
2550                                 p=buf+3;
2551                                 alg=atoi(sstrsep(&p,sep));
2552                                 sstrsep(&p,sep);
2553                                 for(j=0 ; j < SIZE_NUM ; ++j)
2554                                         results[alg][j]+=atof(sstrsep(&p,sep));
2555                                 }
2556                         else if(!strncmp(buf,"+F2:",4))
2557                                 {
2558                                 int k;
2559                                 double d;
2560
2561                                 p=buf+4;
2562                                 k=atoi(sstrsep(&p,sep));
2563                                 sstrsep(&p,sep);
2564
2565                                 d=atof(sstrsep(&p,sep));
2566                                 if(n)
2567                                         rsa_results[k][0]=1/(1/rsa_results[k][0]+1/d);
2568                                 else
2569                                         rsa_results[k][0]=d;
2570
2571                                 d=atof(sstrsep(&p,sep));
2572                                 if(n)
2573                                         rsa_results[k][1]=1/(1/rsa_results[k][1]+1/d);
2574                                 else
2575                                         rsa_results[k][1]=d;
2576                                 }
2577                         else if(!strncmp(buf,"+F2:",4))
2578                                 {
2579                                 int k;
2580                                 double d;
2581
2582                                 p=buf+4;
2583                                 k=atoi(sstrsep(&p,sep));
2584                                 sstrsep(&p,sep);
2585
2586                                 d=atof(sstrsep(&p,sep));
2587                                 if(n)
2588                                         rsa_results[k][0]=1/(1/rsa_results[k][0]+1/d);
2589                                 else
2590                                         rsa_results[k][0]=d;
2591
2592                                 d=atof(sstrsep(&p,sep));
2593                                 if(n)
2594                                         rsa_results[k][1]=1/(1/rsa_results[k][1]+1/d);
2595                                 else
2596                                         rsa_results[k][1]=d;
2597                                 }
2598                         else if(!strncmp(buf,"+F3:",4))
2599                                 {
2600                                 int k;
2601                                 double d;
2602
2603                                 p=buf+4;
2604                                 k=atoi(sstrsep(&p,sep));
2605                                 sstrsep(&p,sep);
2606
2607                                 d=atof(sstrsep(&p,sep));
2608                                 if(n)
2609                                         dsa_results[k][0]=1/(1/dsa_results[k][0]+1/d);
2610                                 else
2611                                         dsa_results[k][0]=d;
2612
2613                                 d=atof(sstrsep(&p,sep));
2614                                 if(n)
2615                                         dsa_results[k][1]=1/(1/dsa_results[k][1]+1/d);
2616                                 else
2617                                         dsa_results[k][1]=d;
2618                                 }
2619 #ifndef OPENSSL_NO_ECDSA
2620                         else if(!strncmp(buf,"+F4:",4))
2621                                 {
2622                                 int k;
2623                                 double d;
2624
2625                                 p=buf+4;
2626                                 k=atoi(sstrsep(&p,sep));
2627                                 sstrsep(&p,sep);
2628
2629                                 d=atof(sstrsep(&p,sep));
2630                                 if(n)
2631                                         ecdsa_results[k][0]=1/(1/ecdsa_results[k][0]+1/d);
2632                                 else
2633                                         ecdsa_results[k][0]=d;
2634
2635                                 d=atof(sstrsep(&p,sep));
2636                                 if(n)
2637                                         ecdsa_results[k][1]=1/(1/ecdsa_results[k][1]+1/d);
2638                                 else
2639                                         ecdsa_results[k][1]=d;
2640                                 }
2641 #endif
2642
2643 #ifndef OPENSSL_NO_ECDH
2644                         else if(!strncmp(buf,"+F5:",4))
2645                                 {
2646                                 int k;
2647                                 double d;
2648
2649                                 p=buf+4;
2650                                 k=atoi(sstrsep(&p,sep));
2651                                 sstrsep(&p,sep);
2652
2653                                 d=atof(sstrsep(&p,sep));
2654                                 if(n)
2655                                         ecdh_results[k][0]=1/(1/ecdh_results[k][0]+1/d);
2656                                 else
2657                                         ecdh_results[k][0]=d;
2658
2659                                 }
2660 #endif
2661
2662                         else if(!strncmp(buf,"+H:",3))
2663                                 {
2664                                 }
2665                         else
2666                                 fprintf(stderr,"Unknown type '%s' from child %d\n",buf,n);
2667                         }
2668                 }
2669         return 1;
2670         }
2671 #endif
2672 #endif