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