apps/speed.c

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