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