apps/speed.c

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