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