apps/speed.c

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