apps/speed.c

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