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