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