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