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