apps/speed.c

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