apps/speed.c

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