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