crypto/openssl-0.9/apps/speed.c

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