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