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