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