apps/speed.c

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