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