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