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