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