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
 704
 705         j=0;
 706         argc--;
 707         argv++;
 708         while (argc)
 709                 {
 710                 if      ((argc > 0) && (strcmp(*argv,"-elapsed") == 0))
 711                         {
 712                         usertime = 0;
 713                         j--;    /* Otherwise, -elapsed gets confused with
 714                                    an algorithm. */
 715                         }
 716                 else if ((argc > 0) && (strcmp(*argv,"-evp") == 0))
 717                         {
 718                         argc--;
 719                         argv++;
 720                         if(argc == 0)
 721                                 {
 722                                 BIO_printf(bio_err,"no EVP given\n");
 723                                 goto end;
 724                                 }
 725                         evp_cipher=EVP_get_cipherbyname(*argv);
 726                         if(!evp_cipher)
 727                                 {
 728                                 evp_md=EVP_get_digestbyname(*argv);
 729                                 }
 730                         if(!evp_cipher && !evp_md)
 731                                 {
 732                                 BIO_printf(bio_err,"%s is an unknown cipher or digest\n",*argv);
 733                                 goto end;
 734                                 }
 735                         doit[D_EVP]=1;
 736                         }
 737                 else if (argc > 0 && !strcmp(*argv,"-decrypt"))
 738                         {
 739                         decrypt=1;
 740                         j--;    /* Otherwise, -elapsed gets confused with
 741                                    an algorithm. */
 742                         }
 743 #ifndef OPENSSL_NO_ENGINE
 744                 else if ((argc > 0) && (strcmp(*argv,"-engine") == 0))
 745                         {
 746                         argc--;
 747                         argv++;
 748                         if(argc == 0)
 749                                 {
 750                                 BIO_printf(bio_err,"no engine given\n");
 751                                 goto end;
 752                                 }
 753                         setup_engine(bio_err, *argv, 0);
 754                         /* j will be increased again further down.  We just
 755                            don't want speed to confuse an engine with an
 756                            algorithm, especially when none is given (which
 757                            means all of them should be run) */
 758                         j--;
 759                         }
 760 #endif
 761 #ifndef NO_FORK
 762                 else if ((argc > 0) && (strcmp(*argv,"-multi") == 0))
 763                         {
 764                         argc--;
 765                         argv++;
 766                         if(argc == 0)
 767                                 {
 768                                 BIO_printf(bio_err,"no multi count given\n");
 769                                 goto end;
 770                                 }
 771                         multi=atoi(argv[0]);
 772                         if(multi <= 0)
 773                             {
 774                                 BIO_printf(bio_err,"bad multi count\n");
 775                                 goto end;
 776                                 }
 777                         j--;    /* Otherwise, -mr gets confused with
 778                                    an algorithm. */
 779                         }
 780 #endif
 781                 else if (argc > 0 && !strcmp(*argv,"-mr"))
 782                         {
 783                         mr=1;
 784                         j--;    /* Otherwise, -mr gets confused with
 785                                    an algorithm. */
 786                         }
 787                 else
 788 #ifndef OPENSSL_NO_MD2
 789                 if      (strcmp(*argv,"md2") == 0) doit[D_MD2]=1;
 790                 else
 791 #endif
 792 #ifndef OPENSSL_NO_MDC2
 793                         if (strcmp(*argv,"mdc2") == 0) doit[D_MDC2]=1;
 794                 else
 795 #endif
 796 #ifndef OPENSSL_NO_MD4
 797                         if (strcmp(*argv,"md4") == 0) doit[D_MD4]=1;
 798                 else
 799 #endif
 800 #ifndef OPENSSL_NO_MD5
 801                         if (strcmp(*argv,"md5") == 0) doit[D_MD5]=1;
 802                 else
 803 #endif
 804 #ifndef OPENSSL_NO_MD5
 805                         if (strcmp(*argv,"hmac") == 0) doit[D_HMAC]=1;
 806                 else
 807 #endif
 808 #ifndef OPENSSL_NO_SHA
 809                         if (strcmp(*argv,"sha1") == 0) doit[D_SHA1]=1;
 810                 else
 811                         if (strcmp(*argv,"sha") == 0)   doit[D_SHA1]=1,
 812                                                         doit[D_SHA256]=1,
 813                                                         doit[D_SHA512]=1;
 814                 else
 815 #ifndef OPENSSL_NO_SHA256
 816                         if (strcmp(*argv,"sha256") == 0) doit[D_SHA256]=1;
 817                 else
 818 #endif
 819 #ifndef OPENSSL_NO_SHA512
 820                         if (strcmp(*argv,"sha512") == 0) doit[D_SHA512]=1;
 821                 else
 822 #endif
 823 #endif
 824 #ifndef OPENSSL_NO_WHIRLPOOL
 825                         if (strcmp(*argv,"whirlpool") == 0) doit[D_WHIRLPOOL]=1;
 826                 else
 827 #endif
 828 #ifndef OPENSSL_NO_RIPEMD
 829                         if (strcmp(*argv,"ripemd") == 0) doit[D_RMD160]=1;
 830                 else
 831                         if (strcmp(*argv,"rmd160") == 0) doit[D_RMD160]=1;
 832                 else
 833                         if (strcmp(*argv,"ripemd160") == 0) doit[D_RMD160]=1;
 834                 else
 835 #endif
 836 #ifndef OPENSSL_NO_RC4
 837                         if (strcmp(*argv,"rc4") == 0) doit[D_RC4]=1;
 838                 else
 839 #endif
 840 #ifndef OPENSSL_NO_DES
 841                         if (strcmp(*argv,"des-cbc") == 0) doit[D_CBC_DES]=1;
 842                 else    if (strcmp(*argv,"des-ede3") == 0) doit[D_EDE3_DES]=1;
 843                 else
 844 #endif
 845 #ifndef OPENSSL_NO_AES
 846                         if (strcmp(*argv,"aes-128-cbc") == 0) doit[D_CBC_128_AES]=1;
 847                 else    if (strcmp(*argv,"aes-192-cbc") == 0) doit[D_CBC_192_AES]=1;
 848                 else    if (strcmp(*argv,"aes-256-cbc") == 0) doit[D_CBC_256_AES]=1;
 849                 else    if (strcmp(*argv,"aes-128-ige") == 0) doit[D_IGE_128_AES]=1;
 850                 else    if (strcmp(*argv,"aes-192-ige") == 0) doit[D_IGE_192_AES]=1;
 851                 else    if (strcmp(*argv,"aes-256-ige") == 0) doit[D_IGE_256_AES]=1;
 852                 else
 853 #endif
 854 #ifndef OPENSSL_NO_CAMELLIA
 855                         if (strcmp(*argv,"camellia-128-cbc") == 0) doit[D_CBC_128_CML]=1;
 856                 else    if (strcmp(*argv,"camellia-192-cbc") == 0) doit[D_CBC_192_CML]=1;
 857                 else    if (strcmp(*argv,"camellia-256-cbc") == 0) doit[D_CBC_256_CML]=1;
 858                 else
 859 #endif
 860 #ifndef OPENSSL_NO_RSA
 861 #if 0 /* was: #ifdef RSAref */
 862                         if (strcmp(*argv,"rsaref") == 0)
 863                         {
 864                         RSA_set_default_openssl_method(RSA_PKCS1_RSAref());
 865                         j--;
 866                         }
 867                 else
 868 #endif
 869 #ifndef RSA_NULL
 870                         if (strcmp(*argv,"openssl") == 0)
 871                         {
 872                         RSA_set_default_method(RSA_PKCS1_SSLeay());
 873                         j--;
 874                         }
 875                 else
 876 #endif
 877 #endif /* !OPENSSL_NO_RSA */
 878                      if (strcmp(*argv,"dsa512") == 0) dsa_doit[R_DSA_512]=2;
 879                 else if (strcmp(*argv,"dsa1024") == 0) dsa_doit[R_DSA_1024]=2;
 880                 else if (strcmp(*argv,"dsa2048") == 0) dsa_doit[R_DSA_2048]=2;
 881                 else if (strcmp(*argv,"rsa512") == 0) rsa_doit[R_RSA_512]=2;
 882                 else if (strcmp(*argv,"rsa1024") == 0) rsa_doit[R_RSA_1024]=2;
 883                 else if (strcmp(*argv,"rsa2048") == 0) rsa_doit[R_RSA_2048]=2;
 884                 else if (strcmp(*argv,"rsa4096") == 0) rsa_doit[R_RSA_4096]=2;
 885                 else
 886 #ifndef OPENSSL_NO_RC2
 887                      if (strcmp(*argv,"rc2-cbc") == 0) doit[D_CBC_RC2]=1;
 888                 else if (strcmp(*argv,"rc2") == 0) doit[D_CBC_RC2]=1;
 889                 else
 890 #endif
 891 #ifndef OPENSSL_NO_RC5
 892                      if (strcmp(*argv,"rc5-cbc") == 0) doit[D_CBC_RC5]=1;
 893                 else if (strcmp(*argv,"rc5") == 0) doit[D_CBC_RC5]=1;
 894                 else
 895 #endif
 896 #ifndef OPENSSL_NO_IDEA
 897                      if (strcmp(*argv,"idea-cbc") == 0) doit[D_CBC_IDEA]=1;
 898                 else if (strcmp(*argv,"idea") == 0) doit[D_CBC_IDEA]=1;
 899                 else
 900 #endif
 901 #ifndef OPENSSL_NO_SEED
 902                      if (strcmp(*argv,"seed-cbc") == 0) doit[D_CBC_SEED]=1;
 903                 else if (strcmp(*argv,"seed") == 0) doit[D_CBC_SEED]=1;
 904                 else
 905 #endif
 906 #ifndef OPENSSL_NO_BF
 907                      if (strcmp(*argv,"bf-cbc") == 0) doit[D_CBC_BF]=1;
 908                 else if (strcmp(*argv,"blowfish") == 0) doit[D_CBC_BF]=1;
 909                 else if (strcmp(*argv,"bf") == 0) doit[D_CBC_BF]=1;
 910                 else
 911 #endif
 912 #ifndef OPENSSL_NO_CAST
 913                      if (strcmp(*argv,"cast-cbc") == 0) doit[D_CBC_CAST]=1;
 914                 else if (strcmp(*argv,"cast") == 0) doit[D_CBC_CAST]=1;
 915                 else if (strcmp(*argv,"cast5") == 0) doit[D_CBC_CAST]=1;
 916                 else
 917 #endif
 918 #ifndef OPENSSL_NO_DES
 919                         if (strcmp(*argv,"des") == 0)
 920                         {
 921                         doit[D_CBC_DES]=1;
 922                         doit[D_EDE3_DES]=1;
 923                         }
 924                 else
 925 #endif
 926 #ifndef OPENSSL_NO_AES
 927                         if (strcmp(*argv,"aes") == 0)
 928                         {
 929                         doit[D_CBC_128_AES]=1;
 930                         doit[D_CBC_192_AES]=1;
 931                         doit[D_CBC_256_AES]=1;
 932                         }
 933                 else if (strcmp(*argv,"ghash") == 0)
 934                         {
 935                         doit[D_GHASH]=1;
 936                         }
 937                 else
 938 #endif
 939 #ifndef OPENSSL_NO_CAMELLIA
 940                         if (strcmp(*argv,"camellia") == 0)
 941                         {
 942                         doit[D_CBC_128_CML]=1;
 943                         doit[D_CBC_192_CML]=1;
 944                         doit[D_CBC_256_CML]=1;
 945                         }
 946                 else
 947 #endif
 948 #ifndef OPENSSL_NO_RSA
 949                         if (strcmp(*argv,"rsa") == 0)
 950                         {
 951                         rsa_doit[R_RSA_512]=1;
 952                         rsa_doit[R_RSA_1024]=1;
 953                         rsa_doit[R_RSA_2048]=1;
 954                         rsa_doit[R_RSA_4096]=1;
 955                         }
 956                 else
 957 #endif
 958 #ifndef OPENSSL_NO_DSA
 959                         if (strcmp(*argv,"dsa") == 0)
 960                         {
 961                         dsa_doit[R_DSA_512]=1;
 962                         dsa_doit[R_DSA_1024]=1;
 963                         dsa_doit[R_DSA_2048]=1;
 964                         }
 965                 else
 966 #endif
 967 #ifndef OPENSSL_NO_ECDSA
 968                      if (strcmp(*argv,"ecdsap160") == 0) ecdsa_doit[R_EC_P160]=2;
 969                 else if (strcmp(*argv,"ecdsap192") == 0) ecdsa_doit[R_EC_P192]=2;
 970                 else if (strcmp(*argv,"ecdsap224") == 0) ecdsa_doit[R_EC_P224]=2;
 971                 else if (strcmp(*argv,"ecdsap256") == 0) ecdsa_doit[R_EC_P256]=2;
 972                 else if (strcmp(*argv,"ecdsap384") == 0) ecdsa_doit[R_EC_P384]=2;
 973                 else if (strcmp(*argv,"ecdsap521") == 0) ecdsa_doit[R_EC_P521]=2;
 974                 else if (strcmp(*argv,"ecdsak163") == 0) ecdsa_doit[R_EC_K163]=2;
 975                 else if (strcmp(*argv,"ecdsak233") == 0) ecdsa_doit[R_EC_K233]=2;
 976                 else if (strcmp(*argv,"ecdsak283") == 0) ecdsa_doit[R_EC_K283]=2;
 977                 else if (strcmp(*argv,"ecdsak409") == 0) ecdsa_doit[R_EC_K409]=2;
 978                 else if (strcmp(*argv,"ecdsak571") == 0) ecdsa_doit[R_EC_K571]=2;
 979                 else if (strcmp(*argv,"ecdsab163") == 0) ecdsa_doit[R_EC_B163]=2;
 980                 else if (strcmp(*argv,"ecdsab233") == 0) ecdsa_doit[R_EC_B233]=2;
 981                 else if (strcmp(*argv,"ecdsab283") == 0) ecdsa_doit[R_EC_B283]=2;
 982                 else if (strcmp(*argv,"ecdsab409") == 0) ecdsa_doit[R_EC_B409]=2;
 983                 else if (strcmp(*argv,"ecdsab571") == 0) ecdsa_doit[R_EC_B571]=2;
 984                 else if (strcmp(*argv,"ecdsa") == 0)
 985                         {
 986                         for (i=0; i < EC_NUM; i++)
 987                                 ecdsa_doit[i]=1;
 988                         }
 989                 else
 990 #endif
 991 #ifndef OPENSSL_NO_ECDH
 992                          if (strcmp(*argv,"ecdhp160") == 0) ecdh_doit[R_EC_P160]=2;
 993                 else if (strcmp(*argv,"ecdhp192") == 0) ecdh_doit[R_EC_P192]=2;
 994                 else if (strcmp(*argv,"ecdhp224") == 0) ecdh_doit[R_EC_P224]=2;
 995                 else if (strcmp(*argv,"ecdhp256") == 0) ecdh_doit[R_EC_P256]=2;
 996                 else if (strcmp(*argv,"ecdhp384") == 0) ecdh_doit[R_EC_P384]=2;
 997                 else if (strcmp(*argv,"ecdhp521") == 0) ecdh_doit[R_EC_P521]=2;
 998                 else if (strcmp(*argv,"ecdhk163") == 0) ecdh_doit[R_EC_K163]=2;
 999                 else if (strcmp(*argv,"ecdhk233") == 0) ecdh_doit[R_EC_K233]=2;
1000                 else if (strcmp(*argv,"ecdhk283") == 0) ecdh_doit[R_EC_K283]=2;
1001                 else if (strcmp(*argv,"ecdhk409") == 0) ecdh_doit[R_EC_K409]=2;
1002                 else if (strcmp(*argv,"ecdhk571") == 0) ecdh_doit[R_EC_K571]=2;
1003                 else if (strcmp(*argv,"ecdhb163") == 0) ecdh_doit[R_EC_B163]=2;
1004                 else if (strcmp(*argv,"ecdhb233") == 0) ecdh_doit[R_EC_B233]=2;
1005                 else if (strcmp(*argv,"ecdhb283") == 0) ecdh_doit[R_EC_B283]=2;
1006                 else if (strcmp(*argv,"ecdhb409") == 0) ecdh_doit[R_EC_B409]=2;
1007                 else if (strcmp(*argv,"ecdhb571") == 0) ecdh_doit[R_EC_B571]=2;
1008                 else if (strcmp(*argv,"ecdh") == 0)
1009                         {
1010                         for (i=0; i < EC_NUM; i++)
1011                                 ecdh_doit[i]=1;
1012                         }
1013                 else
1014 #endif
1015                          if (strcmp(*argv,"prime-trial-division") == 0)
1016                         prime_doit[D_PRIME_TRIAL_DIVISION] = 1;
1017                 else if (strcmp(*argv,"prime-trial-division-retry") == 0)
1018                         prime_doit[D_PRIME_TRIAL_DIVISION_RETRY] = 1;
1019                 else if (strcmp(*argv,"prime-coprime") == 0)
1020                         prime_doit[D_PRIME_COPRIME] = 1;
1021                 else
1022                         {
1023                         BIO_printf(bio_err,"Error: bad option or value\n");
1024                         BIO_printf(bio_err,"\n");
1025                         BIO_printf(bio_err,"Available values:\n");
1026 #ifndef OPENSSL_NO_MD2
1027                         BIO_printf(bio_err,"md2      ");
1028 #endif
1029 #ifndef OPENSSL_NO_MDC2
1030                         BIO_printf(bio_err,"mdc2     ");
1031 #endif
1032 #ifndef OPENSSL_NO_MD4
1033                         BIO_printf(bio_err,"md4      ");
1034 #endif
1035 #ifndef OPENSSL_NO_MD5
1036                         BIO_printf(bio_err,"md5      ");
1037 #ifndef OPENSSL_NO_HMAC
1038                         BIO_printf(bio_err,"hmac     ");
1039 #endif
1040 #endif
1041 #ifndef OPENSSL_NO_SHA1
1042                         BIO_printf(bio_err,"sha1     ");
1043 #endif
1044 #ifndef OPENSSL_NO_SHA256
1045                         BIO_printf(bio_err,"sha256   ");
1046 #endif
1047 #ifndef OPENSSL_NO_SHA512
1048                         BIO_printf(bio_err,"sha512   ");
1049 #endif
1050 #ifndef OPENSSL_NO_WHIRLPOOL
1051                         BIO_printf(bio_err,"whirlpool");
1052 #endif
1053 #ifndef OPENSSL_NO_RIPEMD160
1054                         BIO_printf(bio_err,"rmd160");
1055 #endif
1056 #if !defined(OPENSSL_NO_MD2) || !defined(OPENSSL_NO_MDC2) || \
1057     !defined(OPENSSL_NO_MD4) || !defined(OPENSSL_NO_MD5) || \
1058     !defined(OPENSSL_NO_SHA1) || !defined(OPENSSL_NO_RIPEMD160) || \
1059     !defined(OPENSSL_NO_WHIRLPOOL)
1060                         BIO_printf(bio_err,"\n");
1061 #endif
1062
1063 #ifndef OPENSSL_NO_IDEA
1064                         BIO_printf(bio_err,"idea-cbc ");
1065 #endif
1066 #ifndef OPENSSL_NO_SEED
1067                         BIO_printf(bio_err,"seed-cbc ");
1068 #endif
1069 #ifndef OPENSSL_NO_RC2
1070                         BIO_printf(bio_err,"rc2-cbc  ");
1071 #endif
1072 #ifndef OPENSSL_NO_RC5
1073                         BIO_printf(bio_err,"rc5-cbc  ");
1074 #endif
1075 #ifndef OPENSSL_NO_BF
1076                         BIO_printf(bio_err,"bf-cbc");
1077 #endif
1078 #if !defined(OPENSSL_NO_IDEA) || !defined(OPENSSL_NO_SEED) || !defined(OPENSSL_NO_RC2) || \
1079     !defined(OPENSSL_NO_BF) || !defined(OPENSSL_NO_RC5)
1080                         BIO_printf(bio_err,"\n");
1081 #endif
1082 #ifndef OPENSSL_NO_DES
1083                         BIO_printf(bio_err,"des-cbc  des-ede3 ");
1084 #endif
1085 #ifndef OPENSSL_NO_AES
1086                         BIO_printf(bio_err,"aes-128-cbc aes-192-cbc aes-256-cbc ");
1087                         BIO_printf(bio_err,"aes-128-ige aes-192-ige aes-256-ige ");
1088 #endif
1089 #ifndef OPENSSL_NO_CAMELLIA
1090                         BIO_printf(bio_err,"\n");
1091                         BIO_printf(bio_err,"camellia-128-cbc camellia-192-cbc camellia-256-cbc ");
1092 #endif
1093 #ifndef OPENSSL_NO_RC4
1094                         BIO_printf(bio_err,"rc4");
1095 #endif
1096                         BIO_printf(bio_err,"\n");
1097
1098 #ifndef OPENSSL_NO_RSA
1099                         BIO_printf(bio_err,"rsa512   rsa1024  rsa2048  rsa4096\n");
1100 #endif
1101
1102 #ifndef OPENSSL_NO_DSA
1103                         BIO_printf(bio_err,"dsa512   dsa1024  dsa2048\n");
1104 #endif
1105 #ifndef OPENSSL_NO_ECDSA
1106                         BIO_printf(bio_err,"ecdsap160 ecdsap192 ecdsap224 ecdsap256 ecdsap384 ecdsap521\n");
1107                         BIO_printf(bio_err,"ecdsak163 ecdsak233 ecdsak283 ecdsak409 ecdsak571\n");
1108                         BIO_printf(bio_err,"ecdsab163 ecdsab233 ecdsab283 ecdsab409 ecdsab571\n");
1109                         BIO_printf(bio_err,"ecdsa\n");
1110 #endif
1111 #ifndef OPENSSL_NO_ECDH
1112                         BIO_printf(bio_err,"ecdhp160  ecdhp192  ecdhp224  ecdhp256  ecdhp384  ecdhp521\n");
1113                         BIO_printf(bio_err,"ecdhk163  ecdhk233  ecdhk283  ecdhk409  ecdhk571\n");
1114                         BIO_printf(bio_err,"ecdhb163  ecdhb233  ecdhb283  ecdhb409  ecdhb571\n");
1115                         BIO_printf(bio_err,"ecdh\n");
1116 #endif
1117
1118 #ifndef OPENSSL_NO_IDEA
1119                         BIO_printf(bio_err,"idea     ");
1120 #endif
1121 #ifndef OPENSSL_NO_SEED
1122                         BIO_printf(bio_err,"seed     ");
1123 #endif
1124 #ifndef OPENSSL_NO_RC2
1125                         BIO_printf(bio_err,"rc2      ");
1126 #endif
1127 #ifndef OPENSSL_NO_DES
1128                         BIO_printf(bio_err,"des      ");
1129 #endif
1130 #ifndef OPENSSL_NO_AES
1131                         BIO_printf(bio_err,"aes      ");
1132 #endif
1133 #ifndef OPENSSL_NO_CAMELLIA
1134                         BIO_printf(bio_err,"camellia ");
1135 #endif
1136 #ifndef OPENSSL_NO_RSA
1137                         BIO_printf(bio_err,"rsa      ");
1138 #endif
1139 #ifndef OPENSSL_NO_BF
1140                         BIO_printf(bio_err,"blowfish");
1141 #endif
1142 #if !defined(OPENSSL_NO_IDEA) || !defined(OPENSSL_NO_SEED) || \
1143     !defined(OPENSSL_NO_RC2) || !defined(OPENSSL_NO_DES) || \
1144     !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_BF) || \
1145     !defined(OPENSSL_NO_AES) || !defined(OPENSSL_NO_CAMELLIA)
1146                         BIO_printf(bio_err,"\n");
1147 #endif
1148                         BIO_printf(bio_err,"prime-trial-division  prime-coprime\n");
1149
1150                         BIO_printf(bio_err,"\n");
1151                         BIO_printf(bio_err,"Available options:\n");
1152 #if defined(TIMES) || defined(USE_TOD)
1153                         BIO_printf(bio_err,"-elapsed        measure time in real time instead of CPU user time.\n");
1154 #endif
1155 #ifndef OPENSSL_NO_ENGINE
1156                         BIO_printf(bio_err,"-engine e       use engine e, possibly a hardware device.\n");
1157 #endif
1158                         BIO_printf(bio_err,"-evp e          use EVP e.\n");
1159                         BIO_printf(bio_err,"-decrypt        time decryption instead of encryption (only EVP).\n");
1160                         BIO_printf(bio_err,"-mr             produce machine readable output.\n");
1161 #ifndef NO_FORK
1162                         BIO_printf(bio_err,"-multi n        run n benchmarks in parallel.\n");
1163 #endif
1164                         goto end;
1165                         }
1166                 argc--;
1167                 argv++;
1168                 j++;
1169                 }
1170
1171 #ifndef NO_FORK
1172         if(multi && do_multi(multi))
1173                 goto show_res;
1174 #endif
1175
1176         if (j == 0)
1177                 {
1178                 for (i=0; i<ALGOR_NUM; i++)
1179                         {
1180                         if (i != D_EVP)
1181                                 doit[i]=1;
1182                         }
1183                 for (i=0; i<RSA_NUM; i++)
1184                         rsa_doit[i]=1;
1185                 for (i=0; i<DSA_NUM; i++)
1186                         dsa_doit[i]=1;
1187 #ifndef OPENSSL_NO_ECDSA
1188                 for (i=0; i<EC_NUM; i++)
1189                         ecdsa_doit[i]=1;
1190 #endif
1191 #ifndef OPENSSL_NO_ECDH
1192                 for (i=0; i<EC_NUM; i++)
1193                         ecdh_doit[i]=1;
1194 #endif
1195                 }
1196         for (i=0; i<ALGOR_NUM; i++)
1197                 if (doit[i]) pr_header++;
1198
1199         if (usertime == 0 && !mr)
1200                 BIO_printf(bio_err,"You have chosen to measure elapsed time instead of user CPU time.\n");
1201
1202 #ifndef OPENSSL_NO_RSA
1203         for (i=0; i<RSA_NUM; i++)
1204                 {
1205                 const unsigned char *p;
1206
1207                 p=rsa_data[i];
1208                 rsa_key[i]=d2i_RSAPrivateKey(NULL,&p,rsa_data_length[i]);
1209                 if (rsa_key[i] == NULL)
1210                         {
1211                         BIO_printf(bio_err,"internal error loading RSA key number %d\n",i);
1212                         goto end;
1213                         }
1214 #if 0
1215                 else
1216                         {
1217                         BIO_printf(bio_err,mr ? "+RK:%d:"
1218                                    : "Loaded RSA key, %d bit modulus and e= 0x",
1219                                    BN_num_bits(rsa_key[i]->n));
1220                         BN_print(bio_err,rsa_key[i]->e);
1221                         BIO_printf(bio_err,"\n");
1222                         }
1223 #endif
1224                 }
1225 #endif
1226
1227 #ifndef OPENSSL_NO_DSA
1228         dsa_key[0]=get_dsa512();
1229         dsa_key[1]=get_dsa1024();
1230         dsa_key[2]=get_dsa2048();
1231 #endif
1232
1233 #ifndef OPENSSL_NO_DES
1234         DES_set_key_unchecked(&key,&sch);
1235         DES_set_key_unchecked(&key2,&sch2);
1236         DES_set_key_unchecked(&key3,&sch3);
1237 #endif
1238 #ifndef OPENSSL_NO_AES
1239         AES_set_encrypt_key(key16,128,&aes_ks1);
1240         AES_set_encrypt_key(key24,192,&aes_ks2);
1241         AES_set_encrypt_key(key32,256,&aes_ks3);
1242 #endif
1243 #ifndef OPENSSL_NO_CAMELLIA
1244         Camellia_set_key(key16,128,&camellia_ks1);
1245         Camellia_set_key(ckey24,192,&camellia_ks2);
1246         Camellia_set_key(ckey32,256,&camellia_ks3);
1247 #endif
1248 #ifndef OPENSSL_NO_IDEA
1249         idea_set_encrypt_key(key16,&idea_ks);
1250 #endif
1251 #ifndef OPENSSL_NO_SEED
1252         SEED_set_key(key16,&seed_ks);
1253 #endif
1254 #ifndef OPENSSL_NO_RC4
1255         RC4_set_key(&rc4_ks,16,key16);
1256 #endif
1257 #ifndef OPENSSL_NO_RC2
1258         RC2_set_key(&rc2_ks,16,key16,128);
1259 #endif
1260 #ifndef OPENSSL_NO_RC5
1261         RC5_32_set_key(&rc5_ks,16,key16,12);
1262 #endif
1263 #ifndef OPENSSL_NO_BF
1264         BF_set_key(&bf_ks,16,key16);
1265 #endif
1266 #ifndef OPENSSL_NO_CAST
1267         CAST_set_key(&cast_ks,16,key16);
1268 #endif
1269 #ifndef OPENSSL_NO_RSA
1270         memset(rsa_c,0,sizeof(rsa_c));
1271 #endif
1272 #ifndef SIGALRM
1273 #ifndef OPENSSL_NO_DES
1274         BIO_printf(bio_err,"First we calculate the approximate speed ...\n");
1275         count=10;
1276         do      {
1277                 long it;
1278                 count*=2;
1279                 Time_F(START);
1280                 for (it=count; it; it--)
1281                         DES_ecb_encrypt((DES_cblock *)buf,
1282                                 (DES_cblock *)buf,
1283                                 &sch,DES_ENCRYPT);
1284                 d=Time_F(STOP);
1285                 } while (d <3);
1286         save_count=count;
1287         c[D_MD2][0]=count/10;
1288         c[D_MDC2][0]=count/10;
1289         c[D_MD4][0]=count;
1290         c[D_MD5][0]=count;
1291         c[D_HMAC][0]=count;
1292         c[D_SHA1][0]=count;
1293         c[D_RMD160][0]=count;
1294         c[D_RC4][0]=count*5;
1295         c[D_CBC_DES][0]=count;
1296         c[D_EDE3_DES][0]=count/3;
1297         c[D_CBC_IDEA][0]=count;
1298         c[D_CBC_SEED][0]=count;
1299         c[D_CBC_RC2][0]=count;
1300         c[D_CBC_RC5][0]=count;
1301         c[D_CBC_BF][0]=count;
1302         c[D_CBC_CAST][0]=count;
1303         c[D_CBC_128_AES][0]=count;
1304         c[D_CBC_192_AES][0]=count;
1305         c[D_CBC_256_AES][0]=count;
1306         c[D_CBC_128_CML][0]=count;
1307         c[D_CBC_192_CML][0]=count;
1308         c[D_CBC_256_CML][0]=count;
1309         c[D_SHA256][0]=count;
1310         c[D_SHA512][0]=count;
1311         c[D_WHIRLPOOL][0]=count;
1312         c[D_IGE_128_AES][0]=count;
1313         c[D_IGE_192_AES][0]=count;
1314         c[D_IGE_256_AES][0]=count;
1315         c[D_GHASH][0]=count;
1316
1317         for (i=1; i<SIZE_NUM; i++)
1318                 {
1319                 long l0,l1;
1320
1321                 l0=(long)lengths[0];
1322                 l1=(long)lengths[i];
1323
1324                 c[D_MD2][i]=c[D_MD2][0]*4*l0/l1;
1325                 c[D_MDC2][i]=c[D_MDC2][0]*4*l0/l1;
1326                 c[D_MD4][i]=c[D_MD4][0]*4*l0/l1;
1327                 c[D_MD5][i]=c[D_MD5][0]*4*l0/l1;
1328                 c[D_HMAC][i]=c[D_HMAC][0]*4*l0/l1;
1329                 c[D_SHA1][i]=c[D_SHA1][0]*4*l0/l1;
1330                 c[D_RMD160][i]=c[D_RMD160][0]*4*l0/l1;
1331                 c[D_SHA256][i]=c[D_SHA256][0]*4*l0/l1;
1332                 c[D_SHA512][i]=c[D_SHA512][0]*4*l0/l1;
1333                 c[D_WHIRLPOOL][i]=c[D_WHIRLPOOL][0]*4*l0/l1;
1334
1335                 l0=(long)lengths[i-1];
1336
1337                 c[D_RC4][i]=c[D_RC4][i-1]*l0/l1;
1338                 c[D_CBC_DES][i]=c[D_CBC_DES][i-1]*l0/l1;
1339                 c[D_EDE3_DES][i]=c[D_EDE3_DES][i-1]*l0/l1;
1340                 c[D_CBC_IDEA][i]=c[D_CBC_IDEA][i-1]*l0/l1;
1341                 c[D_CBC_SEED][i]=c[D_CBC_SEED][i-1]*l0/l1;
1342                 c[D_CBC_RC2][i]=c[D_CBC_RC2][i-1]*l0/l1;
1343                 c[D_CBC_RC5][i]=c[D_CBC_RC5][i-1]*l0/l1;
1344                 c[D_CBC_BF][i]=c[D_CBC_BF][i-1]*l0/l1;
1345                 c[D_CBC_CAST][i]=c[D_CBC_CAST][i-1]*l0/l1;
1346                 c[D_CBC_128_AES][i]=c[D_CBC_128_AES][i-1]*l0/l1;
1347                 c[D_CBC_192_AES][i]=c[D_CBC_192_AES][i-1]*l0/l1;
1348                 c[D_CBC_256_AES][i]=c[D_CBC_256_AES][i-1]*l0/l1;
1349                 c[D_CBC_128_CML][i]=c[D_CBC_128_CML][i-1]*l0/l1;
1350                 c[D_CBC_192_CML][i]=c[D_CBC_192_CML][i-1]*l0/l1;
1351                 c[D_CBC_256_CML][i]=c[D_CBC_256_CML][i-1]*l0/l1;
1352                 c[D_IGE_128_AES][i]=c[D_IGE_128_AES][i-1]*l0/l1;
1353                 c[D_IGE_192_AES][i]=c[D_IGE_192_AES][i-1]*l0/l1;
1354                 c[D_IGE_256_AES][i]=c[D_IGE_256_AES][i-1]*l0/l1;
1355                 }
1356
1357         prime_c[D_PRIME_TRIAL_DIVISION]=count;
1358         prime_c[D_PRIME_TRIAL_DIVISION_RETRY]=count;
1359         prime_c[D_PRIME_COPRIME]=count;
1360
1361 #ifndef OPENSSL_NO_RSA
1362         rsa_c[R_RSA_512][0]=count/2000;
1363         rsa_c[R_RSA_512][1]=count/400;
1364         for (i=1; i<RSA_NUM; i++)
1365                 {
1366                 rsa_c[i][0]=rsa_c[i-1][0]/8;
1367                 rsa_c[i][1]=rsa_c[i-1][1]/4;
1368                 if ((rsa_doit[i] <= 1) && (rsa_c[i][0] == 0))
1369                         rsa_doit[i]=0;
1370                 else
1371                         {
1372                         if (rsa_c[i][0] == 0)
1373                                 {
1374                                 rsa_c[i][0]=1;
1375                                 rsa_c[i][1]=20;
1376                                 }
1377                         }
1378                 }
1379 #endif
1380
1381 #ifndef OPENSSL_NO_DSA
1382         dsa_c[R_DSA_512][0]=count/1000;
1383         dsa_c[R_DSA_512][1]=count/1000/2;
1384         for (i=1; i<DSA_NUM; i++)
1385                 {
1386                 dsa_c[i][0]=dsa_c[i-1][0]/4;
1387                 dsa_c[i][1]=dsa_c[i-1][1]/4;
1388                 if ((dsa_doit[i] <= 1) && (dsa_c[i][0] == 0))
1389                         dsa_doit[i]=0;
1390                 else
1391                         {
1392                         if (dsa_c[i] == 0)
1393                                 {
1394                                 dsa_c[i][0]=1;
1395                                 dsa_c[i][1]=1;
1396                                 }
1397                         }
1398                 }
1399 #endif
1400
1401 #ifndef OPENSSL_NO_ECDSA
1402         ecdsa_c[R_EC_P160][0]=count/1000;
1403         ecdsa_c[R_EC_P160][1]=count/1000/2;
1404         for (i=R_EC_P192; i<=R_EC_P521; i++)
1405                 {
1406                 ecdsa_c[i][0]=ecdsa_c[i-1][0]/2;
1407                 ecdsa_c[i][1]=ecdsa_c[i-1][1]/2;
1408                 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1409                         ecdsa_doit[i]=0;
1410                 else
1411                         {
1412                         if (ecdsa_c[i] == 0)
1413                                 {
1414                                 ecdsa_c[i][0]=1;
1415                                 ecdsa_c[i][1]=1;
1416                                 }
1417                         }
1418                 }
1419         ecdsa_c[R_EC_K163][0]=count/1000;
1420         ecdsa_c[R_EC_K163][1]=count/1000/2;
1421         for (i=R_EC_K233; i<=R_EC_K571; i++)
1422                 {
1423                 ecdsa_c[i][0]=ecdsa_c[i-1][0]/2;
1424                 ecdsa_c[i][1]=ecdsa_c[i-1][1]/2;
1425                 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1426                         ecdsa_doit[i]=0;
1427                 else
1428                         {
1429                         if (ecdsa_c[i] == 0)
1430                                 {
1431                                 ecdsa_c[i][0]=1;
1432                                 ecdsa_c[i][1]=1;
1433                                 }
1434                         }
1435                 }
1436         ecdsa_c[R_EC_B163][0]=count/1000;
1437         ecdsa_c[R_EC_B163][1]=count/1000/2;
1438         for (i=R_EC_B233; i<=R_EC_B571; i++)
1439                 {
1440                 ecdsa_c[i][0]=ecdsa_c[i-1][0]/2;
1441                 ecdsa_c[i][1]=ecdsa_c[i-1][1]/2;
1442                 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1443                         ecdsa_doit[i]=0;
1444                 else
1445                         {
1446                         if (ecdsa_c[i] == 0)
1447                                 {
1448                                 ecdsa_c[i][0]=1;
1449                                 ecdsa_c[i][1]=1;
1450                                 }
1451                         }
1452                 }
1453 #endif
1454
1455 #ifndef OPENSSL_NO_ECDH
1456         ecdh_c[R_EC_P160][0]=count/1000;
1457         ecdh_c[R_EC_P160][1]=count/1000;
1458         for (i=R_EC_P192; i<=R_EC_P521; i++)
1459                 {
1460                 ecdh_c[i][0]=ecdh_c[i-1][0]/2;
1461                 ecdh_c[i][1]=ecdh_c[i-1][1]/2;
1462                 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1463                         ecdh_doit[i]=0;
1464                 else
1465                         {
1466                         if (ecdh_c[i] == 0)
1467                                 {
1468                                 ecdh_c[i][0]=1;
1469                                 ecdh_c[i][1]=1;
1470                                 }
1471                         }
1472                 }
1473         ecdh_c[R_EC_K163][0]=count/1000;
1474         ecdh_c[R_EC_K163][1]=count/1000;
1475         for (i=R_EC_K233; i<=R_EC_K571; i++)
1476                 {
1477                 ecdh_c[i][0]=ecdh_c[i-1][0]/2;
1478                 ecdh_c[i][1]=ecdh_c[i-1][1]/2;
1479                 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1480                         ecdh_doit[i]=0;
1481                 else
1482                         {
1483                         if (ecdh_c[i] == 0)
1484                                 {
1485                                 ecdh_c[i][0]=1;
1486                                 ecdh_c[i][1]=1;
1487                                 }
1488                         }
1489                 }
1490         ecdh_c[R_EC_B163][0]=count/1000;
1491         ecdh_c[R_EC_B163][1]=count/1000;
1492         for (i=R_EC_B233; i<=R_EC_B571; i++)
1493                 {
1494                 ecdh_c[i][0]=ecdh_c[i-1][0]/2;
1495                 ecdh_c[i][1]=ecdh_c[i-1][1]/2;
1496                 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1497                         ecdh_doit[i]=0;
1498                 else
1499                         {
1500                         if (ecdh_c[i] == 0)
1501                                 {
1502                                 ecdh_c[i][0]=1;
1503                                 ecdh_c[i][1]=1;
1504                                 }
1505                         }
1506                 }
1507 #endif
1508
1509 #define COND(d) (count < (d))
1510 #define COUNT(d) (d)
1511 #else
1512 /* not worth fixing */
1513 # error "You cannot disable DES on systems without SIGALRM."
1514 #endif /* OPENSSL_NO_DES */
1515 #else
1516 #define COND(c) (run && count<0x7fffffff)
1517 #define COUNT(d) (count)
1518 #ifndef _WIN32
1519         signal(SIGALRM,sig_done);
1520 #endif
1521 #endif /* SIGALRM */
1522
1523 #ifndef OPENSSL_NO_MD2
1524         if (doit[D_MD2])
1525                 {
1526                 for (j=0; j<SIZE_NUM; j++)
1527                         {
1528                         print_message(names[D_MD2],c[D_MD2][j],lengths[j]);
1529                         Time_F(START);
1530                         for (count=0,run=1; COND(c[D_MD2][j]); count++)
1531                                 EVP_Digest(buf,(unsigned long)lengths[j],&(md2[0]),NULL,EVP_md2(),NULL);
1532                         d=Time_F(STOP);
1533                         print_result(D_MD2,j,count,d);
1534                         }
1535                 }
1536 #endif
1537 #ifndef OPENSSL_NO_MDC2
1538         if (doit[D_MDC2])
1539                 {
1540                 for (j=0; j<SIZE_NUM; j++)
1541                         {
1542                         print_message(names[D_MDC2],c[D_MDC2][j],lengths[j]);
1543                         Time_F(START);
1544                         for (count=0,run=1; COND(c[D_MDC2][j]); count++)
1545                                 EVP_Digest(buf,(unsigned long)lengths[j],&(mdc2[0]),NULL,EVP_mdc2(),NULL);
1546                         d=Time_F(STOP);
1547                         print_result(D_MDC2,j,count,d);
1548                         }
1549                 }
1550 #endif
1551
1552 #ifndef OPENSSL_NO_MD4
1553         if (doit[D_MD4])
1554                 {
1555                 for (j=0; j<SIZE_NUM; j++)
1556                         {
1557                         print_message(names[D_MD4],c[D_MD4][j],lengths[j]);
1558                         Time_F(START);
1559                         for (count=0,run=1; COND(c[D_MD4][j]); count++)
1560                                 EVP_Digest(&(buf[0]),(unsigned long)lengths[j],&(md4[0]),NULL,EVP_md4(),NULL);
1561                         d=Time_F(STOP);
1562                         print_result(D_MD4,j,count,d);
1563                         }
1564                 }
1565 #endif
1566
1567 #ifndef OPENSSL_NO_MD5
1568         if (doit[D_MD5])
1569                 {
1570                 for (j=0; j<SIZE_NUM; j++)
1571                         {
1572                         print_message(names[D_MD5],c[D_MD5][j],lengths[j]);
1573                         Time_F(START);
1574                         for (count=0,run=1; COND(c[D_MD5][j]); count++)
1575                                 MD5(buf,lengths[j],md5);
1576                         d=Time_F(STOP);
1577                         print_result(D_MD5,j,count,d);
1578                         }
1579                 }
1580 #endif
1581
1582 #if !defined(OPENSSL_NO_MD5) && !defined(OPENSSL_NO_HMAC)
1583         if (doit[D_HMAC])
1584                 {
1585                 HMAC_CTX hctx;
1586
1587                 HMAC_CTX_init(&hctx);
1588                 HMAC_Init_ex(&hctx,(unsigned char *)"This is a key...",
1589                         16,EVP_md5(), NULL);
1590
1591                 for (j=0; j<SIZE_NUM; j++)
1592                         {
1593                         print_message(names[D_HMAC],c[D_HMAC][j],lengths[j]);
1594                         Time_F(START);
1595                         for (count=0,run=1; COND(c[D_HMAC][j]); count++)
1596                                 {
1597                                 HMAC_Init_ex(&hctx,NULL,0,NULL,NULL);
1598                                 HMAC_Update(&hctx,buf,lengths[j]);
1599                                 HMAC_Final(&hctx,&(hmac[0]),NULL);
1600                                 }
1601                         d=Time_F(STOP);
1602                         print_result(D_HMAC,j,count,d);
1603                         }
1604                 HMAC_CTX_cleanup(&hctx);
1605                 }
1606 #endif
1607 #ifndef OPENSSL_NO_SHA
1608         if (doit[D_SHA1])
1609                 {
1610                 for (j=0; j<SIZE_NUM; j++)
1611                         {
1612                         print_message(names[D_SHA1],c[D_SHA1][j],lengths[j]);
1613                         Time_F(START);
1614                         for (count=0,run=1; COND(c[D_SHA1][j]); count++)
1615 #if 0
1616                                 EVP_Digest(buf,(unsigned long)lengths[j],&(sha[0]),NULL,EVP_sha1(),NULL);
1617 #else
1618                                 SHA1(buf,lengths[j],sha);
1619 #endif
1620                         d=Time_F(STOP);
1621                         print_result(D_SHA1,j,count,d);
1622                         }
1623                 }
1624
1625 #ifndef OPENSSL_NO_SHA256
1626         if (doit[D_SHA256])
1627                 {
1628                 for (j=0; j<SIZE_NUM; j++)
1629                         {
1630                         print_message(names[D_SHA256],c[D_SHA256][j],lengths[j]);
1631                         Time_F(START);
1632                         for (count=0,run=1; COND(c[D_SHA256][j]); count++)
1633                                 SHA256(buf,lengths[j],sha256);
1634                         d=Time_F(STOP);
1635                         print_result(D_SHA256,j,count,d);
1636                         }
1637                 }
1638 #endif
1639
1640 #ifndef OPENSSL_NO_SHA512
1641         if (doit[D_SHA512])
1642                 {
1643                 for (j=0; j<SIZE_NUM; j++)
1644                         {
1645                         print_message(names[D_SHA512],c[D_SHA512][j],lengths[j]);
1646                         Time_F(START);
1647                         for (count=0,run=1; COND(c[D_SHA512][j]); count++)
1648                                 SHA512(buf,lengths[j],sha512);
1649                         d=Time_F(STOP);
1650                         print_result(D_SHA512,j,count,d);
1651                         }
1652                 }
1653 #endif
1654 #endif
1655
1656 #ifndef OPENSSL_NO_WHIRLPOOL
1657         if (doit[D_WHIRLPOOL])
1658                 {
1659                 for (j=0; j<SIZE_NUM; j++)
1660                         {
1661                         print_message(names[D_WHIRLPOOL],c[D_WHIRLPOOL][j],lengths[j]);
1662                         Time_F(START);
1663                         for (count=0,run=1; COND(c[D_WHIRLPOOL][j]); count++)
1664                                 WHIRLPOOL(buf,lengths[j],whirlpool);
1665                         d=Time_F(STOP);
1666                         print_result(D_WHIRLPOOL,j,count,d);
1667                         }
1668                 }
1669 #endif
1670
1671 #ifndef OPENSSL_NO_RIPEMD
1672         if (doit[D_RMD160])
1673                 {
1674                 for (j=0; j<SIZE_NUM; j++)
1675                         {
1676                         print_message(names[D_RMD160],c[D_RMD160][j],lengths[j]);
1677                         Time_F(START);
1678                         for (count=0,run=1; COND(c[D_RMD160][j]); count++)
1679                                 EVP_Digest(buf,(unsigned long)lengths[j],&(rmd160[0]),NULL,EVP_ripemd160(),NULL);
1680                         d=Time_F(STOP);
1681                         print_result(D_RMD160,j,count,d);
1682                         }
1683                 }
1684 #endif
1685 #ifndef OPENSSL_NO_RC4
1686         if (doit[D_RC4])
1687                 {
1688                 for (j=0; j<SIZE_NUM; j++)
1689                         {
1690                         print_message(names[D_RC4],c[D_RC4][j],lengths[j]);
1691                         Time_F(START);
1692                         for (count=0,run=1; COND(c[D_RC4][j]); count++)
1693                                 RC4(&rc4_ks,(unsigned int)lengths[j],
1694                                         buf,buf);
1695                         d=Time_F(STOP);
1696                         print_result(D_RC4,j,count,d);
1697                         }
1698                 }
1699 #endif
1700 #ifndef OPENSSL_NO_DES
1701         if (doit[D_CBC_DES])
1702                 {
1703                 for (j=0; j<SIZE_NUM; j++)
1704                         {
1705                         print_message(names[D_CBC_DES],c[D_CBC_DES][j],lengths[j]);
1706                         Time_F(START);
1707                         for (count=0,run=1; COND(c[D_CBC_DES][j]); count++)
1708                                 DES_ncbc_encrypt(buf,buf,lengths[j],&sch,
1709                                                  &DES_iv,DES_ENCRYPT);
1710                         d=Time_F(STOP);
1711                         print_result(D_CBC_DES,j,count,d);
1712                         }
1713                 }
1714
1715         if (doit[D_EDE3_DES])
1716                 {
1717                 for (j=0; j<SIZE_NUM; j++)
1718                         {
1719                         print_message(names[D_EDE3_DES],c[D_EDE3_DES][j],lengths[j]);
1720                         Time_F(START);
1721                         for (count=0,run=1; COND(c[D_EDE3_DES][j]); count++)
1722                                 DES_ede3_cbc_encrypt(buf,buf,lengths[j],
1723                                                      &sch,&sch2,&sch3,
1724                                                      &DES_iv,DES_ENCRYPT);
1725                         d=Time_F(STOP);
1726                         print_result(D_EDE3_DES,j,count,d);
1727                         }
1728                 }
1729 #endif
1730 #ifndef OPENSSL_NO_AES
1731         if (doit[D_CBC_128_AES])
1732                 {
1733                 for (j=0; j<SIZE_NUM; j++)
1734                         {
1735                         print_message(names[D_CBC_128_AES],c[D_CBC_128_AES][j],lengths[j]);
1736                         Time_F(START);
1737                         for (count=0,run=1; COND(c[D_CBC_128_AES][j]); count++)
1738                                 AES_cbc_encrypt(buf,buf,
1739                                         (unsigned long)lengths[j],&aes_ks1,
1740                                         iv,AES_ENCRYPT);
1741                         d=Time_F(STOP);
1742                         print_result(D_CBC_128_AES,j,count,d);
1743                         }
1744                 }
1745         if (doit[D_CBC_192_AES])
1746                 {
1747                 for (j=0; j<SIZE_NUM; j++)
1748                         {
1749                         print_message(names[D_CBC_192_AES],c[D_CBC_192_AES][j],lengths[j]);
1750                         Time_F(START);
1751                         for (count=0,run=1; COND(c[D_CBC_192_AES][j]); count++)
1752                                 AES_cbc_encrypt(buf,buf,
1753                                         (unsigned long)lengths[j],&aes_ks2,
1754                                         iv,AES_ENCRYPT);
1755                         d=Time_F(STOP);
1756                         print_result(D_CBC_192_AES,j,count,d);
1757                         }
1758                 }
1759         if (doit[D_CBC_256_AES])
1760                 {
1761                 for (j=0; j<SIZE_NUM; j++)
1762                         {
1763                         print_message(names[D_CBC_256_AES],c[D_CBC_256_AES][j],lengths[j]);
1764                         Time_F(START);
1765                         for (count=0,run=1; COND(c[D_CBC_256_AES][j]); count++)
1766                                 AES_cbc_encrypt(buf,buf,
1767                                         (unsigned long)lengths[j],&aes_ks3,
1768                                         iv,AES_ENCRYPT);
1769                         d=Time_F(STOP);
1770                         print_result(D_CBC_256_AES,j,count,d);
1771                         }
1772                 }
1773
1774         if (doit[D_IGE_128_AES])
1775                 {
1776                 for (j=0; j<SIZE_NUM; j++)
1777                         {
1778                         print_message(names[D_IGE_128_AES],c[D_IGE_128_AES][j],lengths[j]);
1779                         Time_F(START);
1780                         for (count=0,run=1; COND(c[D_IGE_128_AES][j]); count++)
1781                                 AES_ige_encrypt(buf,buf2,
1782                                         (unsigned long)lengths[j],&aes_ks1,
1783                                         iv,AES_ENCRYPT);
1784                         d=Time_F(STOP);
1785                         print_result(D_IGE_128_AES,j,count,d);
1786                         }
1787                 }
1788         if (doit[D_IGE_192_AES])
1789                 {
1790                 for (j=0; j<SIZE_NUM; j++)
1791                         {
1792                         print_message(names[D_IGE_192_AES],c[D_IGE_192_AES][j],lengths[j]);
1793                         Time_F(START);
1794                         for (count=0,run=1; COND(c[D_IGE_192_AES][j]); count++)
1795                                 AES_ige_encrypt(buf,buf2,
1796                                         (unsigned long)lengths[j],&aes_ks2,
1797                                         iv,AES_ENCRYPT);
1798                         d=Time_F(STOP);
1799                         print_result(D_IGE_192_AES,j,count,d);
1800                         }
1801                 }
1802         if (doit[D_IGE_256_AES])
1803                 {
1804                 for (j=0; j<SIZE_NUM; j++)
1805                         {
1806                         print_message(names[D_IGE_256_AES],c[D_IGE_256_AES][j],lengths[j]);
1807                         Time_F(START);
1808                         for (count=0,run=1; COND(c[D_IGE_256_AES][j]); count++)
1809                                 AES_ige_encrypt(buf,buf2,
1810                                         (unsigned long)lengths[j],&aes_ks3,
1811                                         iv,AES_ENCRYPT);
1812                         d=Time_F(STOP);
1813                         print_result(D_IGE_256_AES,j,count,d);
1814                         }
1815                 }
1816         if (doit[D_GHASH])
1817                 {
1818                 GCM128_CONTEXT *ctx = CRYPTO_gcm128_new(&aes_ks1,(block128_f)AES_encrypt);
1819                 CRYPTO_gcm128_setiv (ctx,(unsigned char *)"0123456789ab",12);
1820
1821                 for (j=0; j<SIZE_NUM; j++)
1822                         {
1823                         print_message(names[D_GHASH],c[D_GHASH][j],lengths[j]);
1824                         Time_F(START);
1825                         for (count=0,run=1; COND(c[D_GHASH][j]); count++)
1826                                 CRYPTO_gcm128_aad(ctx,buf,lengths[j]);
1827                         d=Time_F(STOP);
1828                         print_result(D_GHASH,j,count,d);
1829                         }
1830                 CRYPTO_gcm128_release(ctx);
1831                 }
1832
1833 #endif
1834 #ifndef OPENSSL_NO_CAMELLIA
1835         if (doit[D_CBC_128_CML])
1836                 {
1837                 for (j=0; j<SIZE_NUM; j++)
1838                         {
1839                         print_message(names[D_CBC_128_CML],c[D_CBC_128_CML][j],lengths[j]);
1840                         Time_F(START);
1841                         for (count=0,run=1; COND(c[D_CBC_128_CML][j]); count++)
1842                                 Camellia_cbc_encrypt(buf,buf,
1843                                         (unsigned long)lengths[j],&camellia_ks1,
1844                                         iv,CAMELLIA_ENCRYPT);
1845                         d=Time_F(STOP);
1846                         print_result(D_CBC_128_CML,j,count,d);
1847                         }
1848                 }
1849         if (doit[D_CBC_192_CML])
1850                 {
1851                 for (j=0; j<SIZE_NUM; j++)
1852                         {
1853                         print_message(names[D_CBC_192_CML],c[D_CBC_192_CML][j],lengths[j]);
1854                         Time_F(START);
1855                         for (count=0,run=1; COND(c[D_CBC_192_CML][j]); count++)
1856                                 Camellia_cbc_encrypt(buf,buf,
1857                                         (unsigned long)lengths[j],&camellia_ks2,
1858                                         iv,CAMELLIA_ENCRYPT);
1859                         d=Time_F(STOP);
1860                         print_result(D_CBC_192_CML,j,count,d);
1861                         }
1862                 }
1863         if (doit[D_CBC_256_CML])
1864                 {
1865                 for (j=0; j<SIZE_NUM; j++)
1866                         {
1867                         print_message(names[D_CBC_256_CML],c[D_CBC_256_CML][j],lengths[j]);
1868                         Time_F(START);
1869                         for (count=0,run=1; COND(c[D_CBC_256_CML][j]); count++)
1870                                 Camellia_cbc_encrypt(buf,buf,
1871                                         (unsigned long)lengths[j],&camellia_ks3,
1872                                         iv,CAMELLIA_ENCRYPT);
1873                         d=Time_F(STOP);
1874                         print_result(D_CBC_256_CML,j,count,d);
1875                         }
1876                 }
1877
1878 #endif
1879 #ifndef OPENSSL_NO_IDEA
1880         if (doit[D_CBC_IDEA])
1881                 {
1882                 for (j=0; j<SIZE_NUM; j++)
1883                         {
1884                         print_message(names[D_CBC_IDEA],c[D_CBC_IDEA][j],lengths[j]);
1885                         Time_F(START);
1886                         for (count=0,run=1; COND(c[D_CBC_IDEA][j]); count++)
1887                                 idea_cbc_encrypt(buf,buf,
1888                                         (unsigned long)lengths[j],&idea_ks,
1889                                         iv,IDEA_ENCRYPT);
1890                         d=Time_F(STOP);
1891                         print_result(D_CBC_IDEA,j,count,d);
1892                         }
1893                 }
1894 #endif
1895 #ifndef OPENSSL_NO_SEED
1896         if (doit[D_CBC_SEED])
1897                 {
1898                 for (j=0; j<SIZE_NUM; j++)
1899                         {
1900                         print_message(names[D_CBC_SEED],c[D_CBC_SEED][j],lengths[j]);
1901                         Time_F(START);
1902                         for (count=0,run=1; COND(c[D_CBC_SEED][j]); count++)
1903                                 SEED_cbc_encrypt(buf,buf,
1904                                         (unsigned long)lengths[j],&seed_ks,iv,1);
1905                         d=Time_F(STOP);
1906                         print_result(D_CBC_SEED,j,count,d);
1907                         }
1908                 }
1909 #endif
1910 #ifndef OPENSSL_NO_RC2
1911         if (doit[D_CBC_RC2])
1912                 {
1913                 for (j=0; j<SIZE_NUM; j++)
1914                         {
1915                         print_message(names[D_CBC_RC2],c[D_CBC_RC2][j],lengths[j]);
1916                         Time_F(START);
1917                         for (count=0,run=1; COND(c[D_CBC_RC2][j]); count++)
1918                                 RC2_cbc_encrypt(buf,buf,
1919                                         (unsigned long)lengths[j],&rc2_ks,
1920                                         iv,RC2_ENCRYPT);
1921                         d=Time_F(STOP);
1922                         print_result(D_CBC_RC2,j,count,d);
1923                         }
1924                 }
1925 #endif
1926 #ifndef OPENSSL_NO_RC5
1927         if (doit[D_CBC_RC5])
1928                 {
1929                 for (j=0; j<SIZE_NUM; j++)
1930                         {
1931                         print_message(names[D_CBC_RC5],c[D_CBC_RC5][j],lengths[j]);
1932                         Time_F(START);
1933                         for (count=0,run=1; COND(c[D_CBC_RC5][j]); count++)
1934                                 RC5_32_cbc_encrypt(buf,buf,
1935                                         (unsigned long)lengths[j],&rc5_ks,
1936                                         iv,RC5_ENCRYPT);
1937                         d=Time_F(STOP);
1938                         print_result(D_CBC_RC5,j,count,d);
1939                         }
1940                 }
1941 #endif
1942 #ifndef OPENSSL_NO_BF
1943         if (doit[D_CBC_BF])
1944                 {
1945                 for (j=0; j<SIZE_NUM; j++)
1946                         {
1947                         print_message(names[D_CBC_BF],c[D_CBC_BF][j],lengths[j]);
1948                         Time_F(START);
1949                         for (count=0,run=1; COND(c[D_CBC_BF][j]); count++)
1950                                 BF_cbc_encrypt(buf,buf,
1951                                         (unsigned long)lengths[j],&bf_ks,
1952                                         iv,BF_ENCRYPT);
1953                         d=Time_F(STOP);
1954                         print_result(D_CBC_BF,j,count,d);
1955                         }
1956                 }
1957 #endif
1958 #ifndef OPENSSL_NO_CAST
1959         if (doit[D_CBC_CAST])
1960                 {
1961                 for (j=0; j<SIZE_NUM; j++)
1962                         {
1963                         print_message(names[D_CBC_CAST],c[D_CBC_CAST][j],lengths[j]);
1964                         Time_F(START);
1965                         for (count=0,run=1; COND(c[D_CBC_CAST][j]); count++)
1966                                 CAST_cbc_encrypt(buf,buf,
1967                                         (unsigned long)lengths[j],&cast_ks,
1968                                         iv,CAST_ENCRYPT);
1969                         d=Time_F(STOP);
1970                         print_result(D_CBC_CAST,j,count,d);
1971                         }
1972                 }
1973 #endif
1974
1975         if (doit[D_EVP])
1976                 {
1977                 for (j=0; j<SIZE_NUM; j++)
1978                         {
1979                         if (evp_cipher)
1980                                 {
1981                                 EVP_CIPHER_CTX ctx;
1982                                 int outl;
1983
1984                                 names[D_EVP]=OBJ_nid2ln(evp_cipher->nid);
1985                                 /* -O3 -fschedule-insns messes up an
1986                                  * optimization here!  names[D_EVP]
1987                                  * somehow becomes NULL */
1988                                 print_message(names[D_EVP],save_count,
1989                                         lengths[j]);
1990
1991                                 EVP_CIPHER_CTX_init(&ctx);
1992                                 if(decrypt)
1993                                         EVP_DecryptInit_ex(&ctx,evp_cipher,NULL,key16,iv);
1994                                 else
1995                                         EVP_EncryptInit_ex(&ctx,evp_cipher,NULL,key16,iv);
1996                                 EVP_CIPHER_CTX_set_padding(&ctx, 0);
1997
1998                                 Time_F(START);
1999                                 if(decrypt)
2000                                         for (count=0,run=1; COND(save_count*4*lengths[0]/lengths[j]); count++)
2001                                                 EVP_DecryptUpdate(&ctx,buf,&outl,buf,lengths[j]);
2002                                 else
2003                                         for (count=0,run=1; COND(save_count*4*lengths[0]/lengths[j]); count++)
2004                                                 EVP_EncryptUpdate(&ctx,buf,&outl,buf,lengths[j]);
2005                                 if(decrypt)
2006                                         EVP_DecryptFinal_ex(&ctx,buf,&outl);
2007                                 else
2008                                         EVP_EncryptFinal_ex(&ctx,buf,&outl);
2009                                 d=Time_F(STOP);
2010                                 EVP_CIPHER_CTX_cleanup(&ctx);
2011                                 }
2012                         if (evp_md)
2013                                 {
2014                                 names[D_EVP]=OBJ_nid2ln(evp_md->type);
2015                                 print_message(names[D_EVP],save_count,
2016                                         lengths[j]);
2017
2018                                 Time_F(START);
2019                                 for (count=0,run=1; COND(save_count*4*lengths[0]/lengths[j]); count++)
2020                                         EVP_Digest(buf,lengths[j],&(md[0]),NULL,evp_md,NULL);
2021
2022                                 d=Time_F(STOP);
2023                                 }
2024                         print_result(D_EVP,j,count,d);
2025                         }
2026                 }
2027
2028         if (prime_doit[D_PRIME_TRIAL_DIVISION])
2029                 {
2030                 BIGNUM *rnd = BN_new();
2031                 BIGNUM *add = BN_new();
2032                 BN_CTX *ctx = BN_CTX_new();
2033
2034                 BN_set_word(add, 2);
2035                 prime_print_message(prime_names[D_PRIME_TRIAL_DIVISION],
2036                                                         prime_c[D_PRIME_TRIAL_DIVISION]);
2037
2038                 Time_F(START);
2039                 for (count=0, run=1; COND(prime_c[D_PRIME_TRIAL_DIVISION]); count++)
2040                         bn_probable_prime_dh(rnd, 1024, add, NULL, ctx);
2041
2042                 d=Time_F(STOP);
2043                 prime_print_result(D_PRIME_TRIAL_DIVISION, count, d);
2044
2045                 BN_CTX_free(ctx);
2046                 BN_free(add);
2047                 BN_free(rnd);
2048                 }
2049
2050         if (prime_doit[D_PRIME_TRIAL_DIVISION_RETRY])
2051                 {
2052                 BIGNUM *rnd = BN_new();
2053                 BN_CTX *ctx = BN_CTX_new();
2054
2055                 prime_print_message(prime_names[D_PRIME_TRIAL_DIVISION_RETRY],
2056                                                         prime_c[D_PRIME_TRIAL_DIVISION_RETRY]);
2057
2058                 Time_F(START);
2059                 for (count=0, run=1; COND(prime_c[D_PRIME_TRIAL_DIVISION_RETRY]); count++)
2060                         bn_probable_prime_dh_retry(rnd, 1024, ctx);
2061
2062                 d=Time_F(STOP);
2063                 prime_print_result(D_PRIME_TRIAL_DIVISION_RETRY, count, d);
2064
2065                 BN_CTX_free(ctx);
2066                 BN_free(rnd);
2067                 }
2068
2069         if (prime_doit[D_PRIME_COPRIME])
2070                 {
2071                 BIGNUM *rnd = BN_new();
2072                 BN_CTX *ctx = BN_CTX_new();
2073
2074                 prime_print_message(prime_names[D_PRIME_COPRIME],
2075                                                         prime_c[D_PRIME_COPRIME]);
2076
2077                 Time_F(START);
2078                 for (count=0, run=1; COND(prime_c[D_PRIME_COPRIME]); count++)
2079                         bn_probable_prime_dh_coprime(rnd, 1024, ctx);
2080
2081                 d=Time_F(STOP);
2082                 prime_print_result(D_PRIME_COPRIME, count, d);
2083
2084                 BN_CTX_free(ctx);
2085                 BN_free(rnd);
2086                 }
2087
2088         RAND_pseudo_bytes(buf,36);
2089 #ifndef OPENSSL_NO_RSA
2090         for (j=0; j<RSA_NUM; j++)
2091                 {
2092                 int ret;
2093                 if (!rsa_doit[j]) continue;
2094                 ret=RSA_sign(NID_md5_sha1, buf,36, buf2, &rsa_num, rsa_key[j]);
2095                 if (ret == 0)
2096                         {
2097                         BIO_printf(bio_err,"RSA sign failure.  No RSA sign will be done.\n");
2098                         ERR_print_errors(bio_err);
2099                         rsa_count=1;
2100                         }
2101                 else
2102                         {
2103                         pkey_print_message("private","rsa",
2104                                 rsa_c[j][0],rsa_bits[j],
2105                                 RSA_SECONDS);
2106 /*                      RSA_blinding_on(rsa_key[j],NULL); */
2107                         Time_F(START);
2108                         for (count=0,run=1; COND(rsa_c[j][0]); count++)
2109                                 {
2110                                 ret=RSA_sign(NID_md5_sha1, buf,36, buf2,
2111                                         &rsa_num, rsa_key[j]);
2112                                 if (ret == 0)
2113                                         {
2114                                         BIO_printf(bio_err,
2115                                                 "RSA sign failure\n");
2116                                         ERR_print_errors(bio_err);
2117                                         count=1;
2118                                         break;
2119                                         }
2120                                 }
2121                         d=Time_F(STOP);
2122                         BIO_printf(bio_err,mr ? "+R1:%ld:%d:%.2f\n"
2123                                    : "%ld %d bit private RSA's in %.2fs\n",
2124                                    count,rsa_bits[j],d);
2125                         rsa_results[j][0]=d/(double)count;
2126                         rsa_count=count;
2127                         }
2128
2129 #if 1
2130                 ret=RSA_verify(NID_md5_sha1, buf,36, buf2, rsa_num, rsa_key[j]);
2131                 if (ret <= 0)
2132                         {
2133                         BIO_printf(bio_err,"RSA verify failure.  No RSA verify will be done.\n");
2134                         ERR_print_errors(bio_err);
2135                         rsa_doit[j] = 0;
2136                         }
2137                 else
2138                         {
2139                         pkey_print_message("public","rsa",
2140                                 rsa_c[j][1],rsa_bits[j],
2141                                 RSA_SECONDS);
2142                         Time_F(START);
2143                         for (count=0,run=1; COND(rsa_c[j][1]); count++)
2144                                 {
2145                                 ret=RSA_verify(NID_md5_sha1, buf,36, buf2,
2146                                         rsa_num, rsa_key[j]);
2147                                 if (ret <= 0)
2148                                         {
2149                                         BIO_printf(bio_err,
2150                                                 "RSA verify failure\n");
2151                                         ERR_print_errors(bio_err);
2152                                         count=1;
2153                                         break;
2154                                         }
2155                                 }
2156                         d=Time_F(STOP);
2157                         BIO_printf(bio_err,mr ? "+R2:%ld:%d:%.2f\n"
2158                                    : "%ld %d bit public RSA's in %.2fs\n",
2159                                    count,rsa_bits[j],d);
2160                         rsa_results[j][1]=d/(double)count;
2161                         }
2162 #endif
2163
2164                 if (rsa_count <= 1)
2165                         {
2166                         /* if longer than 10s, don't do any more */
2167                         for (j++; j<RSA_NUM; j++)
2168                                 rsa_doit[j]=0;
2169                         }
2170                 }
2171 #endif
2172
2173         RAND_pseudo_bytes(buf,20);
2174 #ifndef OPENSSL_NO_DSA
2175         if (RAND_status() != 1)
2176                 {
2177                 RAND_seed(rnd_seed, sizeof rnd_seed);
2178                 rnd_fake = 1;
2179                 }
2180         for (j=0; j<DSA_NUM; j++)
2181                 {
2182                 unsigned int kk;
2183                 int ret;
2184
2185                 if (!dsa_doit[j]) continue;
2186 /*              DSA_generate_key(dsa_key[j]); */
2187 /*              DSA_sign_setup(dsa_key[j],NULL); */
2188                 ret=DSA_sign(EVP_PKEY_DSA,buf,20,buf2,
2189                         &kk,dsa_key[j]);
2190                 if (ret == 0)
2191                         {
2192                         BIO_printf(bio_err,"DSA sign failure.  No DSA sign will be done.\n");
2193                         ERR_print_errors(bio_err);
2194                         rsa_count=1;
2195                         }
2196                 else
2197                         {
2198                         pkey_print_message("sign","dsa",
2199                                 dsa_c[j][0],dsa_bits[j],
2200                                 DSA_SECONDS);
2201                         Time_F(START);
2202                         for (count=0,run=1; COND(dsa_c[j][0]); count++)
2203                                 {
2204                                 ret=DSA_sign(EVP_PKEY_DSA,buf,20,buf2,
2205                                         &kk,dsa_key[j]);
2206                                 if (ret == 0)
2207                                         {
2208                                         BIO_printf(bio_err,
2209                                                 "DSA sign failure\n");
2210                                         ERR_print_errors(bio_err);
2211                                         count=1;
2212                                         break;
2213                                         }
2214                                 }
2215                         d=Time_F(STOP);
2216                         BIO_printf(bio_err,mr ? "+R3:%ld:%d:%.2f\n"
2217                                    : "%ld %d bit DSA signs in %.2fs\n",
2218                                    count,dsa_bits[j],d);
2219                         dsa_results[j][0]=d/(double)count;
2220                         rsa_count=count;
2221                         }
2222
2223                 ret=DSA_verify(EVP_PKEY_DSA,buf,20,buf2,
2224                         kk,dsa_key[j]);
2225                 if (ret <= 0)
2226                         {
2227                         BIO_printf(bio_err,"DSA verify failure.  No DSA verify will be done.\n");
2228                         ERR_print_errors(bio_err);
2229                         dsa_doit[j] = 0;
2230                         }
2231                 else
2232                         {
2233                         pkey_print_message("verify","dsa",
2234                                 dsa_c[j][1],dsa_bits[j],
2235                                 DSA_SECONDS);
2236                         Time_F(START);
2237                         for (count=0,run=1; COND(dsa_c[j][1]); count++)
2238                                 {
2239                                 ret=DSA_verify(EVP_PKEY_DSA,buf,20,buf2,
2240                                         kk,dsa_key[j]);
2241                                 if (ret <= 0)
2242                                         {
2243                                         BIO_printf(bio_err,
2244                                                 "DSA verify failure\n");
2245                                         ERR_print_errors(bio_err);
2246                                         count=1;
2247                                         break;
2248                                         }
2249                                 }
2250                         d=Time_F(STOP);
2251                         BIO_printf(bio_err,mr ? "+R4:%ld:%d:%.2f\n"
2252                                    : "%ld %d bit DSA verify in %.2fs\n",
2253                                    count,dsa_bits[j],d);
2254                         dsa_results[j][1]=d/(double)count;
2255                         }
2256
2257                 if (rsa_count <= 1)
2258                         {
2259                         /* if longer than 10s, don't do any more */
2260                         for (j++; j<DSA_NUM; j++)
2261                                 dsa_doit[j]=0;
2262                         }
2263                 }
2264         if (rnd_fake) RAND_cleanup();
2265 #endif
2266
2267 #ifndef OPENSSL_NO_ECDSA
2268         if (RAND_status() != 1)
2269                 {
2270                 RAND_seed(rnd_seed, sizeof rnd_seed);
2271                 rnd_fake = 1;
2272                 }
2273         for (j=0; j<EC_NUM; j++)
2274                 {
2275                 int ret;
2276
2277                 if (!ecdsa_doit[j]) continue; /* Ignore Curve */
2278                 ecdsa[j] = EC_KEY_new_by_curve_name(test_curves[j]);
2279                 if (ecdsa[j] == NULL)
2280                         {
2281                         BIO_printf(bio_err,"ECDSA failure.\n");
2282                         ERR_print_errors(bio_err);
2283                         rsa_count=1;
2284                         }
2285                 else
2286                         {
2287 #if 1
2288                         EC_KEY_precompute_mult(ecdsa[j], NULL);
2289 #endif
2290                         /* Perform ECDSA signature test */
2291                         EC_KEY_generate_key(ecdsa[j]);
2292                         ret = ECDSA_sign(0, buf, 20, ecdsasig,
2293                                 &ecdsasiglen, ecdsa[j]);
2294                         if (ret == 0)
2295                                 {
2296                                 BIO_printf(bio_err,"ECDSA sign failure.  No ECDSA sign will be done.\n");
2297                                 ERR_print_errors(bio_err);
2298                                 rsa_count=1;
2299                                 }
2300                         else
2301                                 {
2302                                 pkey_print_message("sign","ecdsa",
2303                                         ecdsa_c[j][0],
2304                                         test_curves_bits[j],
2305                                         ECDSA_SECONDS);
2306
2307                                 Time_F(START);
2308                                 for (count=0,run=1; COND(ecdsa_c[j][0]);
2309                                         count++)
2310                                         {
2311                                         ret=ECDSA_sign(0, buf, 20,
2312                                                 ecdsasig, &ecdsasiglen,
2313                                                 ecdsa[j]);
2314                                         if (ret == 0)
2315                                                 {
2316                                                 BIO_printf(bio_err, "ECDSA sign failure\n");
2317                                                 ERR_print_errors(bio_err);
2318                                                 count=1;
2319                                                 break;
2320                                                 }
2321                                         }
2322                                 d=Time_F(STOP);
2323
2324                                 BIO_printf(bio_err, mr ? "+R5:%ld:%d:%.2f\n" :
2325                                         "%ld %d bit ECDSA signs in %.2fs \n",
2326                                         count, test_curves_bits[j], d);
2327                                 ecdsa_results[j][0]=d/(double)count;
2328                                 rsa_count=count;
2329                                 }
2330
2331                         /* Perform ECDSA verification test */
2332                         ret=ECDSA_verify(0, buf, 20, ecdsasig,
2333                                 ecdsasiglen, ecdsa[j]);
2334                         if (ret != 1)
2335                                 {
2336                                 BIO_printf(bio_err,"ECDSA verify failure.  No ECDSA verify will be done.\n");
2337                                 ERR_print_errors(bio_err);
2338                                 ecdsa_doit[j] = 0;
2339                                 }
2340                         else
2341                                 {
2342                                 pkey_print_message("verify","ecdsa",
2343                                 ecdsa_c[j][1],
2344                                 test_curves_bits[j],
2345                                 ECDSA_SECONDS);
2346                                 Time_F(START);
2347                                 for (count=0,run=1; COND(ecdsa_c[j][1]); count++)
2348                                         {
2349                                         ret=ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[j]);
2350                                         if (ret != 1)
2351                                                 {
2352                                                 BIO_printf(bio_err, "ECDSA verify failure\n");
2353                                                 ERR_print_errors(bio_err);
2354                                                 count=1;
2355                                                 break;
2356                                                 }
2357                                         }
2358                                 d=Time_F(STOP);
2359                                 BIO_printf(bio_err, mr? "+R6:%ld:%d:%.2f\n"
2360                                                 : "%ld %d bit ECDSA verify in %.2fs\n",
2361                                 count, test_curves_bits[j], d);
2362                                 ecdsa_results[j][1]=d/(double)count;
2363                                 }
2364
2365                         if (rsa_count <= 1)
2366                                 {
2367                                 /* if longer than 10s, don't do any more */
2368                                 for (j++; j<EC_NUM; j++)
2369                                 ecdsa_doit[j]=0;
2370                                 }
2371                         }
2372                 }
2373         if (rnd_fake) RAND_cleanup();
2374 #endif
2375
2376 #ifndef OPENSSL_NO_ECDH
2377         if (RAND_status() != 1)
2378                 {
2379                 RAND_seed(rnd_seed, sizeof rnd_seed);
2380                 rnd_fake = 1;
2381                 }
2382         for (j=0; j<EC_NUM; j++)
2383                 {
2384                 if (!ecdh_doit[j]) continue;
2385                 ecdh_a[j] = EC_KEY_new_by_curve_name(test_curves[j]);
2386                 ecdh_b[j] = EC_KEY_new_by_curve_name(test_curves[j]);
2387                 if ((ecdh_a[j] == NULL) || (ecdh_b[j] == NULL))
2388                         {
2389                         BIO_printf(bio_err,"ECDH failure.\n");
2390                         ERR_print_errors(bio_err);
2391                         rsa_count=1;
2392                         }
2393                 else
2394                         {
2395                         /* generate two ECDH key pairs */
2396                         if (!EC_KEY_generate_key(ecdh_a[j]) ||
2397                                 !EC_KEY_generate_key(ecdh_b[j]))
2398                                 {
2399                                 BIO_printf(bio_err,"ECDH key generation failure.\n");
2400                                 ERR_print_errors(bio_err);
2401                                 rsa_count=1;
2402                                 }
2403                         else
2404                                 {
2405                                 /* If field size is not more than 24 octets, then use SHA-1 hash of result;
2406                                  * otherwise, use result (see section 4.8 of draft-ietf-tls-ecc-03.txt).
2407                                  */
2408                                 int field_size, outlen;
2409                                 void *(*kdf)(const void *in, size_t inlen, void *out, size_t *xoutlen);
2410                                 field_size = EC_GROUP_get_degree(EC_KEY_get0_group(ecdh_a[j]));
2411                                 if (field_size <= 24 * 8)
2412                                         {
2413                                         outlen = KDF1_SHA1_len;
2414                                         kdf = KDF1_SHA1;
2415                                         }
2416                                 else
2417                                         {
2418                                         outlen = (field_size+7)/8;
2419                                         kdf = NULL;
2420                                         }
2421                                 secret_size_a = ECDH_compute_key(secret_a, outlen,
2422                                         EC_KEY_get0_public_key(ecdh_b[j]),
2423                                         ecdh_a[j], kdf);
2424                                 secret_size_b = ECDH_compute_key(secret_b, outlen,
2425                                         EC_KEY_get0_public_key(ecdh_a[j]),
2426                                         ecdh_b[j], kdf);
2427                                 if (secret_size_a != secret_size_b)
2428                                         ecdh_checks = 0;
2429                                 else
2430                                         ecdh_checks = 1;
2431
2432                                 for (secret_idx = 0;
2433                                     (secret_idx < secret_size_a)
2434                                         && (ecdh_checks == 1);
2435                                     secret_idx++)
2436                                         {
2437                                         if (secret_a[secret_idx] != secret_b[secret_idx])
2438                                         ecdh_checks = 0;
2439                                         }
2440
2441                                 if (ecdh_checks == 0)
2442                                         {
2443                                         BIO_printf(bio_err,"ECDH computations don't match.\n");
2444                                         ERR_print_errors(bio_err);
2445                                         rsa_count=1;
2446                                         }
2447
2448                                 pkey_print_message("","ecdh",
2449                                 ecdh_c[j][0],
2450                                 test_curves_bits[j],
2451                                 ECDH_SECONDS);
2452                                 Time_F(START);
2453                                 for (count=0,run=1; COND(ecdh_c[j][0]); count++)
2454                                         {
2455                                         ECDH_compute_key(secret_a, outlen,
2456                                         EC_KEY_get0_public_key(ecdh_b[j]),
2457                                         ecdh_a[j], kdf);
2458                                         }
2459                                 d=Time_F(STOP);
2460                                 BIO_printf(bio_err, mr ? "+R7:%ld:%d:%.2f\n" :"%ld %d-bit ECDH ops in %.2fs\n",
2461                                 count, test_curves_bits[j], d);
2462                                 ecdh_results[j][0]=d/(double)count;
2463                                 rsa_count=count;
2464                                 }
2465                         }
2466
2467
2468                 if (rsa_count <= 1)
2469                         {
2470                         /* if longer than 10s, don't do any more */
2471                         for (j++; j<EC_NUM; j++)
2472                         ecdh_doit[j]=0;
2473                         }
2474                 }
2475         if (rnd_fake) RAND_cleanup();
2476 #endif
2477 #ifndef NO_FORK
2478 show_res:
2479 #endif
2480         if(!mr)
2481                 {
2482                 fprintf(stdout,"%s\n",SSLeay_version(SSLEAY_VERSION));
2483         fprintf(stdout,"%s\n",SSLeay_version(SSLEAY_BUILT_ON));
2484                 printf("options:");
2485                 printf("%s ",BN_options());
2486 #ifndef OPENSSL_NO_MD2
2487                 printf("%s ",MD2_options());
2488 #endif
2489 #ifndef OPENSSL_NO_RC4
2490                 printf("%s ",RC4_options());
2491 #endif
2492 #ifndef OPENSSL_NO_DES
2493                 printf("%s ",DES_options());
2494 #endif
2495 #ifndef OPENSSL_NO_AES
2496                 printf("%s ",AES_options());
2497 #endif
2498 #ifndef OPENSSL_NO_IDEA
2499                 printf("%s ",idea_options());
2500 #endif
2501 #ifndef OPENSSL_NO_BF
2502                 printf("%s ",BF_options());
2503 #endif
2504                 fprintf(stdout,"\n%s\n",SSLeay_version(SSLEAY_CFLAGS));
2505                 }
2506
2507         if (pr_header)
2508                 {
2509                 if(mr)
2510                         fprintf(stdout,"+H");
2511                 else
2512                         {
2513                         fprintf(stdout,"The 'numbers' are in 1000s of bytes per second processed.\n");
2514                         fprintf(stdout,"type        ");
2515                         }
2516                 for (j=0;  j<SIZE_NUM; j++)
2517                         fprintf(stdout,mr ? ":%d" : "%7d bytes",lengths[j]);
2518                 fprintf(stdout,"\n");
2519                 }
2520
2521         for (k=0; k<ALGOR_NUM; k++)
2522                 {
2523                 if (!doit[k]) continue;
2524                 if(mr)
2525                         fprintf(stdout,"+F:%d:%s",k,names[k]);
2526                 else
2527                         fprintf(stdout,"%-13s",names[k]);
2528                 for (j=0; j<SIZE_NUM; j++)
2529                         {
2530                         if (results[k][j] > 10000 && !mr)
2531                                 fprintf(stdout," %11.2fk",results[k][j]/1e3);
2532                         else
2533                                 fprintf(stdout,mr ? ":%.2f" : " %11.2f ",results[k][j]);
2534                         }
2535                 fprintf(stdout,"\n");
2536                 }
2537 #ifndef OPENSSL_NO_RSA
2538         j=1;
2539         for (k=0; k<RSA_NUM; k++)
2540                 {
2541                 if (!rsa_doit[k]) continue;
2542                 if (j && !mr)
2543                         {
2544                         printf("%18ssign    verify    sign/s verify/s\n"," ");
2545                         j=0;
2546                         }
2547                 if(mr)
2548                         fprintf(stdout,"+F2:%u:%u:%f:%f\n",
2549                                 k,rsa_bits[k],rsa_results[k][0],
2550                                 rsa_results[k][1]);
2551                 else
2552                         fprintf(stdout,"rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2553                                 rsa_bits[k],rsa_results[k][0],rsa_results[k][1],
2554                                 1.0/rsa_results[k][0],1.0/rsa_results[k][1]);
2555                 }
2556 #endif
2557 #ifndef OPENSSL_NO_DSA
2558         j=1;
2559         for (k=0; k<DSA_NUM; k++)
2560                 {
2561                 if (!dsa_doit[k]) continue;
2562                 if (j && !mr)
2563                         {
2564                         printf("%18ssign    verify    sign/s verify/s\n"," ");
2565                         j=0;
2566                         }
2567                 if(mr)
2568                         fprintf(stdout,"+F3:%u:%u:%f:%f\n",
2569                                 k,dsa_bits[k],dsa_results[k][0],dsa_results[k][1]);
2570                 else
2571                         fprintf(stdout,"dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2572                                 dsa_bits[k],dsa_results[k][0],dsa_results[k][1],
2573                                 1.0/dsa_results[k][0],1.0/dsa_results[k][1]);
2574                 }
2575 #endif
2576 #ifndef OPENSSL_NO_ECDSA
2577         j=1;
2578         for (k=0; k<EC_NUM; k++)
2579                 {
2580                 if (!ecdsa_doit[k]) continue;
2581                 if (j && !mr)
2582                         {
2583                         printf("%30ssign    verify    sign/s verify/s\n"," ");
2584                         j=0;
2585                         }
2586
2587                 if (mr)
2588                         fprintf(stdout,"+F4:%u:%u:%f:%f\n",
2589                                 k, test_curves_bits[k],
2590                                 ecdsa_results[k][0],ecdsa_results[k][1]);
2591                 else
2592                         fprintf(stdout,
2593                                 "%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2594                                 test_curves_bits[k],
2595                                 test_curves_names[k],
2596                                 ecdsa_results[k][0],ecdsa_results[k][1],
2597                                 1.0/ecdsa_results[k][0],1.0/ecdsa_results[k][1]);
2598                 }
2599 #endif
2600
2601
2602 #ifndef OPENSSL_NO_ECDH
2603         j=1;
2604         for (k=0; k<EC_NUM; k++)
2605                 {
2606                 if (!ecdh_doit[k]) continue;
2607                 if (j && !mr)
2608                         {
2609                         printf("%30sop      op/s\n"," ");
2610                         j=0;
2611                         }
2612                 if (mr)
2613                         fprintf(stdout,"+F5:%u:%u:%f:%f\n",
2614                                 k, test_curves_bits[k],
2615                                 ecdh_results[k][0], 1.0/ecdh_results[k][0]);
2616
2617                 else
2618                         fprintf(stdout,"%4u bit ecdh (%s) %8.4fs %8.1f\n",
2619                                 test_curves_bits[k],
2620                                 test_curves_names[k],
2621                                 ecdh_results[k][0], 1.0/ecdh_results[k][0]);
2622                 }
2623 #endif
2624
2625         mret=0;
2626
2627 end:
2628         ERR_print_errors(bio_err);
2629         if (buf != NULL) OPENSSL_free(buf);
2630         if (buf2 != NULL) OPENSSL_free(buf2);
2631 #ifndef OPENSSL_NO_RSA
2632         for (i=0; i<RSA_NUM; i++)
2633                 if (rsa_key[i] != NULL)
2634                         RSA_free(rsa_key[i]);
2635 #endif
2636 #ifndef OPENSSL_NO_DSA
2637         for (i=0; i<DSA_NUM; i++)
2638                 if (dsa_key[i] != NULL)
2639                         DSA_free(dsa_key[i]);
2640 #endif
2641
2642 #ifndef OPENSSL_NO_ECDSA
2643         for (i=0; i<EC_NUM; i++)
2644                 if (ecdsa[i] != NULL)
2645                         EC_KEY_free(ecdsa[i]);
2646 #endif
2647 #ifndef OPENSSL_NO_ECDH
2648         for (i=0; i<EC_NUM; i++)
2649         {
2650                 if (ecdh_a[i] != NULL)
2651                         EC_KEY_free(ecdh_a[i]);
2652                 if (ecdh_b[i] != NULL)
2653                         EC_KEY_free(ecdh_b[i]);
2654         }
2655 #endif
2656
2657         apps_shutdown();
2658         OPENSSL_EXIT(mret);
2659         }
2660
2661 static void print_message(const char *s, long num, int length)
2662         {
2663 #ifdef SIGALRM
2664         BIO_printf(bio_err,mr ? "+DT:%s:%d:%d\n"
2665                    : "Doing %s for %ds on %d size blocks: ",s,SECONDS,length);
2666         (void)BIO_flush(bio_err);
2667         alarm(SECONDS);
2668 #else
2669         BIO_printf(bio_err,mr ? "+DN:%s:%ld:%d\n"
2670                    : "Doing %s %ld times on %d size blocks: ",s,num,length);
2671         (void)BIO_flush(bio_err);
2672 #endif
2673 #ifdef LINT
2674         num=num;
2675 #endif
2676         }
2677
2678 static void prime_print_message(const char *s, long num)
2679         {
2680 #ifdef SIGALRM
2681         BIO_printf(bio_err,mr ? "+DT:%s:%d\n"
2682                    : "Doing %s for %ds: ", s, PRIME_SECONDS);
2683         (void)BIO_flush(bio_err);
2684         alarm(PRIME_SECONDS);
2685 #else
2686         BIO_printf(bio_err,mr ? "+DN:%s:%ld\n"
2687                    : "Doing %s %ld times: ", s, num);
2688         (void)BIO_flush(bio_err);
2689 #endif
2690 #ifdef LINT
2691         num=num;
2692 #endif
2693         }
2694
2695 static void pkey_print_message(const char *str, const char *str2, long num,
2696         int bits, int tm)
2697         {
2698 #ifdef SIGALRM
2699         BIO_printf(bio_err,mr ? "+DTP:%d:%s:%s:%d\n"
2700                            : "Doing %d bit %s %s's for %ds: ",bits,str,str2,tm);
2701         (void)BIO_flush(bio_err);
2702         alarm(tm);
2703 #else
2704         BIO_printf(bio_err,mr ? "+DNP:%ld:%d:%s:%s\n"
2705                            : "Doing %ld %d bit %s %s's: ",num,bits,str,str2);
2706         (void)BIO_flush(bio_err);
2707 #endif
2708 #ifdef LINT
2709         num=num;
2710 #endif
2711         }
2712
2713 static void print_result(int alg,int run_no,int count,double time_used)
2714         {
2715         BIO_printf(bio_err,mr ? "+R:%d:%s:%f\n"
2716                    : "%d %s's in %.2fs\n",count,names[alg],time_used);
2717         results[alg][run_no]=((double)count)/time_used*lengths[run_no];
2718         }
2719
2720 static void prime_print_result(int alg, int count, double time_used)
2721         {
2722         BIO_printf(bio_err,
2723                            mr ? "+R:%d:%s:%f:%f\n" : "%d %s's in %.2fs (%.2f microseconds / run)\n",
2724                            count, prime_names[alg], time_used,
2725                            time_used / ((double)count) * 1000000);
2726         }
2727
2728 #ifndef NO_FORK
2729 static char *sstrsep(char **string, const char *delim)
2730     {
2731     char isdelim[256];
2732     char *token = *string;
2733
2734     if (**string == 0)
2735         return NULL;
2736
2737     memset(isdelim, 0, sizeof isdelim);
2738     isdelim[0] = 1;
2739
2740     while (*delim)
2741         {
2742         isdelim[(unsigned char)(*delim)] = 1;
2743         delim++;
2744         }
2745
2746     while (!isdelim[(unsigned char)(**string)])
2747         {
2748         (*string)++;
2749         }
2750
2751     if (**string)
2752         {
2753         **string = 0;
2754         (*string)++;
2755         }
2756
2757     return token;
2758     }
2759
2760 static int do_multi(int multi)
2761         {
2762         int n;
2763         int fd[2];
2764         int *fds;
2765         static char sep[]=":";
2766
2767         fds=malloc(multi*sizeof *fds);
2768         for(n=0 ; n < multi ; ++n)
2769                 {
2770                 if (pipe(fd) == -1)
2771                         {
2772                         fprintf(stderr, "pipe failure\n");
2773                         exit(1);
2774                         }
2775                 fflush(stdout);
2776                 fflush(stderr);
2777                 if(fork())
2778                         {
2779                         close(fd[1]);
2780                         fds[n]=fd[0];
2781                         }
2782                 else
2783                         {
2784                         close(fd[0]);
2785                         close(1);
2786                         if (dup(fd[1]) == -1)
2787                                 {
2788                                 fprintf(stderr, "dup failed\n");
2789                                 exit(1);
2790                                 }
2791                         close(fd[1]);
2792                         mr=1;
2793                         usertime=0;
2794                         free(fds);
2795                         return 0;
2796                         }
2797                 printf("Forked child %d\n",n);
2798                 }
2799
2800         /* for now, assume the pipe is long enough to take all the output */
2801         for(n=0 ; n < multi ; ++n)
2802                 {
2803                 FILE *f;
2804                 char buf[1024];
2805                 char *p;
2806
2807                 f=fdopen(fds[n],"r");
2808                 while(fgets(buf,sizeof buf,f))
2809                         {
2810                         p=strchr(buf,'\n');
2811                         if(p)
2812                                 *p='\0';
2813                         if(buf[0] != '+')
2814                                 {
2815                                 fprintf(stderr,"Don't understand line '%s' from child %d\n",
2816                                                 buf,n);
2817                                 continue;
2818                                 }
2819                         printf("Got: %s from %d\n",buf,n);
2820                         if(!strncmp(buf,"+F:",3))
2821                                 {
2822                                 int alg;
2823                                 int j;
2824
2825                                 p=buf+3;
2826                                 alg=atoi(sstrsep(&p,sep));
2827                                 sstrsep(&p,sep);
2828                                 for(j=0 ; j < SIZE_NUM ; ++j)
2829                                         results[alg][j]+=atof(sstrsep(&p,sep));
2830                                 }
2831                         else if(!strncmp(buf,"+F2:",4))
2832                                 {
2833                                 int k;
2834                                 double d;
2835
2836                                 p=buf+4;
2837                                 k=atoi(sstrsep(&p,sep));
2838                                 sstrsep(&p,sep);
2839
2840                                 d=atof(sstrsep(&p,sep));
2841                                 if(n)
2842                                         rsa_results[k][0]=1/(1/rsa_results[k][0]+1/d);
2843                                 else
2844                                         rsa_results[k][0]=d;
2845
2846                                 d=atof(sstrsep(&p,sep));
2847                                 if(n)
2848                                         rsa_results[k][1]=1/(1/rsa_results[k][1]+1/d);
2849                                 else
2850                                         rsa_results[k][1]=d;
2851                                 }
2852                         else if(!strncmp(buf,"+F2:",4))
2853                                 {
2854                                 int k;
2855                                 double d;
2856
2857                                 p=buf+4;
2858                                 k=atoi(sstrsep(&p,sep));
2859                                 sstrsep(&p,sep);
2860
2861                                 d=atof(sstrsep(&p,sep));
2862                                 if(n)
2863                                         rsa_results[k][0]=1/(1/rsa_results[k][0]+1/d);
2864                                 else
2865                                         rsa_results[k][0]=d;
2866
2867                                 d=atof(sstrsep(&p,sep));
2868                                 if(n)
2869                                         rsa_results[k][1]=1/(1/rsa_results[k][1]+1/d);
2870                                 else
2871                                         rsa_results[k][1]=d;
2872                                 }
2873 #ifndef OPENSSL_NO_DSA
2874                         else if(!strncmp(buf,"+F3:",4))
2875                                 {
2876                                 int k;
2877                                 double d;
2878
2879                                 p=buf+4;
2880                                 k=atoi(sstrsep(&p,sep));
2881                                 sstrsep(&p,sep);
2882
2883                                 d=atof(sstrsep(&p,sep));
2884                                 if(n)
2885                                         dsa_results[k][0]=1/(1/dsa_results[k][0]+1/d);
2886                                 else
2887                                         dsa_results[k][0]=d;
2888
2889                                 d=atof(sstrsep(&p,sep));
2890                                 if(n)
2891                                         dsa_results[k][1]=1/(1/dsa_results[k][1]+1/d);
2892                                 else
2893                                         dsa_results[k][1]=d;
2894                                 }
2895 #endif
2896 #ifndef OPENSSL_NO_ECDSA
2897                         else if(!strncmp(buf,"+F4:",4))
2898                                 {
2899                                 int k;
2900                                 double d;
2901
2902                                 p=buf+4;
2903                                 k=atoi(sstrsep(&p,sep));
2904                                 sstrsep(&p,sep);
2905
2906                                 d=atof(sstrsep(&p,sep));
2907                                 if(n)
2908                                         ecdsa_results[k][0]=1/(1/ecdsa_results[k][0]+1/d);
2909                                 else
2910                                         ecdsa_results[k][0]=d;
2911
2912                                 d=atof(sstrsep(&p,sep));
2913                                 if(n)
2914                                         ecdsa_results[k][1]=1/(1/ecdsa_results[k][1]+1/d);
2915                                 else
2916                                         ecdsa_results[k][1]=d;
2917                                 }
2918 #endif
2919
2920 #ifndef OPENSSL_NO_ECDH
2921                         else if(!strncmp(buf,"+F5:",4))
2922                                 {
2923                                 int k;
2924                                 double d;
2925
2926                                 p=buf+4;
2927                                 k=atoi(sstrsep(&p,sep));
2928                                 sstrsep(&p,sep);
2929
2930                                 d=atof(sstrsep(&p,sep));
2931                                 if(n)
2932                                         ecdh_results[k][0]=1/(1/ecdh_results[k][0]+1/d);
2933                                 else
2934                                         ecdh_results[k][0]=d;
2935
2936                                 }
2937 #endif
2938
2939                         else if(!strncmp(buf,"+H:",3))
2940                                 {
2941                                 }
2942                         else
2943                                 fprintf(stderr,"Unknown type '%s' from child %d\n",buf,n);
2944                         }
2945
2946                 fclose(f);
2947                 }
2948         free(fds);
2949         return 1;
2950         }
2951 #endif
2952 #endif