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