apps/speed.c

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