apps/speed.c

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