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