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