apps/speed.c

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