apps/speed.c

   1 /*
   2  * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.
   3  * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
   4  *
   5  * Licensed under the OpenSSL license (the "License").  You may not use
   6  * this file except in compliance with the License.  You can obtain a copy
   7  * in the file LICENSE in the source distribution or at
   8  * https://www.openssl.org/source/license.html
   9  */
  10
  11 #undef SECONDS
  12 #define SECONDS                 3
  13 #define RSA_SECONDS             10
  14 #define DSA_SECONDS             10
  15 #define ECDSA_SECONDS   10
  16 #define ECDH_SECONDS    10
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <math.h>
  22 #include "apps.h"
  23 #include "progs.h"
  24 #include <openssl/crypto.h>
  25 #include <openssl/rand.h>
  26 #include <openssl/err.h>
  27 #include <openssl/evp.h>
  28 #include <openssl/objects.h>
  29 #include <openssl/async.h>
  30 #if !defined(OPENSSL_SYS_MSDOS)
  31 # include OPENSSL_UNISTD
  32 #endif
  33
  34 #if defined(_WIN32)
  35 # include <windows.h>
  36 #endif
  37
  38 #include <openssl/bn.h>
  39 #ifndef OPENSSL_NO_DES
  40 # include <openssl/des.h>
  41 #endif
  42 #include <openssl/aes.h>
  43 #ifndef OPENSSL_NO_CAMELLIA
  44 # include <openssl/camellia.h>
  45 #endif
  46 #ifndef OPENSSL_NO_MD2
  47 # include <openssl/md2.h>
  48 #endif
  49 #ifndef OPENSSL_NO_MDC2
  50 # include <openssl/mdc2.h>
  51 #endif
  52 #ifndef OPENSSL_NO_MD4
  53 # include <openssl/md4.h>
  54 #endif
  55 #ifndef OPENSSL_NO_MD5
  56 # include <openssl/md5.h>
  57 #endif
  58 #include <openssl/hmac.h>
  59 #include <openssl/sha.h>
  60 #ifndef OPENSSL_NO_RMD160
  61 # include <openssl/ripemd.h>
  62 #endif
  63 #ifndef OPENSSL_NO_WHIRLPOOL
  64 # include <openssl/whrlpool.h>
  65 #endif
  66 #ifndef OPENSSL_NO_RC4
  67 # include <openssl/rc4.h>
  68 #endif
  69 #ifndef OPENSSL_NO_RC5
  70 # include <openssl/rc5.h>
  71 #endif
  72 #ifndef OPENSSL_NO_RC2
  73 # include <openssl/rc2.h>
  74 #endif
  75 #ifndef OPENSSL_NO_IDEA
  76 # include <openssl/idea.h>
  77 #endif
  78 #ifndef OPENSSL_NO_SEED
  79 # include <openssl/seed.h>
  80 #endif
  81 #ifndef OPENSSL_NO_BF
  82 # include <openssl/blowfish.h>
  83 #endif
  84 #ifndef OPENSSL_NO_CAST
  85 # include <openssl/cast.h>
  86 #endif
  87 #ifndef OPENSSL_NO_RSA
  88 # include <openssl/rsa.h>
  89 # include "./testrsa.h"
  90 #endif
  91 #include <openssl/x509.h>
  92 #ifndef OPENSSL_NO_DSA
  93 # include <openssl/dsa.h>
  94 # include "./testdsa.h"
  95 #endif
  96 #ifndef OPENSSL_NO_EC
  97 # include <openssl/ec.h>
  98 #endif
  99 #include <openssl/modes.h>
 100
 101 #ifndef HAVE_FORK
 102 # if defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_WINDOWS)
 103 #  define HAVE_FORK 0
 104 # else
 105 #  define HAVE_FORK 1
 106 # endif
 107 #endif
 108
 109 #if HAVE_FORK
 110 # undef NO_FORK
 111 #else
 112 # define NO_FORK
 113 #endif
 114
 115 #define MAX_MISALIGNMENT 63
 116 #define MAX_ECDH_SIZE   256
 117 #define MISALIGN        64
 118
 119 typedef struct openssl_speed_sec_st {
 120     int sym;
 121     int rsa;
 122     int dsa;
 123     int ecdsa;
 124     int ecdh;
 125 } openssl_speed_sec_t;
 126
 127 static volatile int run = 0;
 128
 129 static int mr = 0;
 130 static int usertime = 1;
 131
 132 #ifndef OPENSSL_NO_MD2
 133 static int EVP_Digest_MD2_loop(void *args);
 134 #endif
 135
 136 #ifndef OPENSSL_NO_MDC2
 137 static int EVP_Digest_MDC2_loop(void *args);
 138 #endif
 139 #ifndef OPENSSL_NO_MD4
 140 static int EVP_Digest_MD4_loop(void *args);
 141 #endif
 142 #ifndef OPENSSL_NO_MD5
 143 static int MD5_loop(void *args);
 144 static int HMAC_loop(void *args);
 145 #endif
 146 static int SHA1_loop(void *args);
 147 static int SHA256_loop(void *args);
 148 static int SHA512_loop(void *args);
 149 #ifndef OPENSSL_NO_WHIRLPOOL
 150 static int WHIRLPOOL_loop(void *args);
 151 #endif
 152 #ifndef OPENSSL_NO_RMD160
 153 static int EVP_Digest_RMD160_loop(void *args);
 154 #endif
 155 #ifndef OPENSSL_NO_RC4
 156 static int RC4_loop(void *args);
 157 #endif
 158 #ifndef OPENSSL_NO_DES
 159 static int DES_ncbc_encrypt_loop(void *args);
 160 static int DES_ede3_cbc_encrypt_loop(void *args);
 161 #endif
 162 static int AES_cbc_128_encrypt_loop(void *args);
 163 static int AES_cbc_192_encrypt_loop(void *args);
 164 static int AES_ige_128_encrypt_loop(void *args);
 165 static int AES_cbc_256_encrypt_loop(void *args);
 166 static int AES_ige_192_encrypt_loop(void *args);
 167 static int AES_ige_256_encrypt_loop(void *args);
 168 static int CRYPTO_gcm128_aad_loop(void *args);
 169 static int RAND_bytes_loop(void *args);
 170 static int EVP_Update_loop(void *args);
 171 static int EVP_Update_loop_ccm(void *args);
 172 static int EVP_Update_loop_aead(void *args);
 173 static int EVP_Digest_loop(void *args);
 174 #ifndef OPENSSL_NO_RSA
 175 static int RSA_sign_loop(void *args);
 176 static int RSA_verify_loop(void *args);
 177 #endif
 178 #ifndef OPENSSL_NO_DSA
 179 static int DSA_sign_loop(void *args);
 180 static int DSA_verify_loop(void *args);
 181 #endif
 182 #ifndef OPENSSL_NO_EC
 183 static int ECDSA_sign_loop(void *args);
 184 static int ECDSA_verify_loop(void *args);
 185 #endif
 186
 187 static double Time_F(int s);
 188 static void print_message(const char *s, long num, int length, int tm);
 189 static void pkey_print_message(const char *str, const char *str2,
 190                                long num, unsigned int bits, int sec);
 191 static void print_result(int alg, int run_no, int count, double time_used);
 192 #ifndef NO_FORK
 193 static int do_multi(int multi, int size_num);
 194 #endif
 195
 196 static const int lengths_list[] = {
 197     16, 64, 256, 1024, 8 * 1024, 16 * 1024
 198 };
 199 static const int *lengths = lengths_list;
 200
 201 static const int aead_lengths_list[] = {
 202     2, 31, 136, 1024, 8 * 1024, 16 * 1024
 203 };
 204
 205 #define START   0
 206 #define STOP    1
 207
 208 #ifdef SIGALRM
 209
 210 static void alarmed(int sig)
 211 {
 212     signal(SIGALRM, alarmed);
 213     run = 0;
 214 }
 215
 216 static double Time_F(int s)
 217 {
 218     double ret = app_tminterval(s, usertime);
 219     if (s == STOP)
 220         alarm(0);
 221     return ret;
 222 }
 223
 224 #elif defined(_WIN32)
 225
 226 # define SIGALRM -1
 227
 228 static unsigned int lapse;
 229 static volatile unsigned int schlock;
 230 static void alarm_win32(unsigned int secs)
 231 {
 232     lapse = secs * 1000;
 233 }
 234
 235 # define alarm alarm_win32
 236
 237 static DWORD WINAPI sleepy(VOID * arg)
 238 {
 239     schlock = 1;
 240     Sleep(lapse);
 241     run = 0;
 242     return 0;
 243 }
 244
 245 static double Time_F(int s)
 246 {
 247     double ret;
 248     static HANDLE thr;
 249
 250     if (s == START) {
 251         schlock = 0;
 252         thr = CreateThread(NULL, 4096, sleepy, NULL, 0, NULL);
 253         if (thr == NULL) {
 254             DWORD err = GetLastError();
 255             BIO_printf(bio_err, "unable to CreateThread (%lu)", err);
 256             ExitProcess(err);
 257         }
 258         while (!schlock)
 259             Sleep(0);           /* scheduler spinlock */
 260         ret = app_tminterval(s, usertime);
 261     } else {
 262         ret = app_tminterval(s, usertime);
 263         if (run)
 264             TerminateThread(thr, 0);
 265         CloseHandle(thr);
 266     }
 267
 268     return ret;
 269 }
 270 #else
 271 static double Time_F(int s)
 272 {
 273     return app_tminterval(s, usertime);
 274 }
 275 #endif
 276
 277 static void multiblock_speed(const EVP_CIPHER *evp_cipher, int lengths_single,
 278                              const openssl_speed_sec_t *seconds);
 279
 280 #define found(value, pairs, result)\
 281     opt_found(value, result, pairs, OSSL_NELEM(pairs))
 282 static int opt_found(const char *name, unsigned int *result,
 283                      const OPT_PAIR pairs[], unsigned int nbelem)
 284 {
 285     unsigned int idx;
 286
 287     for (idx = 0; idx < nbelem; ++idx, pairs++)
 288         if (strcmp(name, pairs->name) == 0) {
 289             *result = pairs->retval;
 290             return 1;
 291         }
 292     return 0;
 293 }
 294
 295 typedef enum OPTION_choice {
 296     OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
 297     OPT_ELAPSED, OPT_EVP, OPT_DECRYPT, OPT_ENGINE, OPT_MULTI,
 298     OPT_MR, OPT_MB, OPT_MISALIGN, OPT_ASYNCJOBS, OPT_R_ENUM,
 299     OPT_PRIMES, OPT_SECONDS, OPT_BYTES, OPT_AEAD
 300 } OPTION_CHOICE;
 301
 302 const OPTIONS speed_options[] = {
 303     {OPT_HELP_STR, 1, '-', "Usage: %s [options] ciphers...\n"},
 304     {OPT_HELP_STR, 1, '-', "Valid options are:\n"},
 305     {"help", OPT_HELP, '-', "Display this summary"},
 306     {"evp", OPT_EVP, 's', "Use EVP-named cipher or digest"},
 307     {"decrypt", OPT_DECRYPT, '-',
 308      "Time decryption instead of encryption (only EVP)"},
 309     {"aead", OPT_AEAD, '-',
 310      "Benchmark EVP-named AEAD cipher in TLS-like sequence"},
 311     {"mb", OPT_MB, '-',
 312      "Enable (tls1>=1) multi-block mode on EVP-named cipher"},
 313     {"mr", OPT_MR, '-', "Produce machine readable output"},
 314 #ifndef NO_FORK
 315     {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"},
 316 #endif
 317 #ifndef OPENSSL_NO_ASYNC
 318     {"async_jobs", OPT_ASYNCJOBS, 'p',
 319      "Enable async mode and start specified number of jobs"},
 320 #endif
 321     OPT_R_OPTIONS,
 322 #ifndef OPENSSL_NO_ENGINE
 323     {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
 324 #endif
 325     {"elapsed", OPT_ELAPSED, '-',
 326      "Use wall-clock time instead of CPU user time as divisor"},
 327     {"primes", OPT_PRIMES, 'p', "Specify number of primes (for RSA only)"},
 328     {"seconds", OPT_SECONDS, 'p',
 329      "Run benchmarks for specified amount of seconds"},
 330     {"bytes", OPT_BYTES, 'p',
 331      "Run [non-PKI] benchmarks on custom-sized buffer"},
 332     {"misalign", OPT_MISALIGN, 'p',
 333      "Use specified offset to mis-align buffers"},
 334     {NULL}
 335 };
 336
 337 #define D_MD2           0
 338 #define D_MDC2          1
 339 #define D_MD4           2
 340 #define D_MD5           3
 341 #define D_HMAC          4
 342 #define D_SHA1          5
 343 #define D_RMD160        6
 344 #define D_RC4           7
 345 #define D_CBC_DES       8
 346 #define D_EDE3_DES      9
 347 #define D_CBC_IDEA      10
 348 #define D_CBC_SEED      11
 349 #define D_CBC_RC2       12
 350 #define D_CBC_RC5       13
 351 #define D_CBC_BF        14
 352 #define D_CBC_CAST      15
 353 #define D_CBC_128_AES   16
 354 #define D_CBC_192_AES   17
 355 #define D_CBC_256_AES   18
 356 #define D_CBC_128_CML   19
 357 #define D_CBC_192_CML   20
 358 #define D_CBC_256_CML   21
 359 #define D_EVP           22
 360 #define D_SHA256        23
 361 #define D_SHA512        24
 362 #define D_WHIRLPOOL     25
 363 #define D_IGE_128_AES   26
 364 #define D_IGE_192_AES   27
 365 #define D_IGE_256_AES   28
 366 #define D_GHASH         29
 367 #define D_RAND          30
 368 /* name of algorithms to test */
 369 static const char *names[] = {
 370     "md2", "mdc2", "md4", "md5", "hmac(md5)", "sha1", "rmd160", "rc4",
 371     "des cbc", "des ede3", "idea cbc", "seed cbc",
 372     "rc2 cbc", "rc5-32/12 cbc", "blowfish cbc", "cast cbc",
 373     "aes-128 cbc", "aes-192 cbc", "aes-256 cbc",
 374     "camellia-128 cbc", "camellia-192 cbc", "camellia-256 cbc",
 375     "evp", "sha256", "sha512", "whirlpool",
 376     "aes-128 ige", "aes-192 ige", "aes-256 ige", "ghash",
 377     "rand"
 378 };
 379 #define ALGOR_NUM       OSSL_NELEM(names)
 380
 381 /* list of configured algorithm (remaining) */
 382 static const OPT_PAIR doit_choices[] = {
 383 #ifndef OPENSSL_NO_MD2
 384     {"md2", D_MD2},
 385 #endif
 386 #ifndef OPENSSL_NO_MDC2
 387     {"mdc2", D_MDC2},
 388 #endif
 389 #ifndef OPENSSL_NO_MD4
 390     {"md4", D_MD4},
 391 #endif
 392 #ifndef OPENSSL_NO_MD5
 393     {"md5", D_MD5},
 394     {"hmac", D_HMAC},
 395 #endif
 396     {"sha1", D_SHA1},
 397     {"sha256", D_SHA256},
 398     {"sha512", D_SHA512},
 399 #ifndef OPENSSL_NO_WHIRLPOOL
 400     {"whirlpool", D_WHIRLPOOL},
 401 #endif
 402 #ifndef OPENSSL_NO_RMD160
 403     {"ripemd", D_RMD160},
 404     {"rmd160", D_RMD160},
 405     {"ripemd160", D_RMD160},
 406 #endif
 407 #ifndef OPENSSL_NO_RC4
 408     {"rc4", D_RC4},
 409 #endif
 410 #ifndef OPENSSL_NO_DES
 411     {"des-cbc", D_CBC_DES},
 412     {"des-ede3", D_EDE3_DES},
 413 #endif
 414     {"aes-128-cbc", D_CBC_128_AES},
 415     {"aes-192-cbc", D_CBC_192_AES},
 416     {"aes-256-cbc", D_CBC_256_AES},
 417     {"aes-128-ige", D_IGE_128_AES},
 418     {"aes-192-ige", D_IGE_192_AES},
 419     {"aes-256-ige", D_IGE_256_AES},
 420 #ifndef OPENSSL_NO_RC2
 421     {"rc2-cbc", D_CBC_RC2},
 422     {"rc2", D_CBC_RC2},
 423 #endif
 424 #ifndef OPENSSL_NO_RC5
 425     {"rc5-cbc", D_CBC_RC5},
 426     {"rc5", D_CBC_RC5},
 427 #endif
 428 #ifndef OPENSSL_NO_IDEA
 429     {"idea-cbc", D_CBC_IDEA},
 430     {"idea", D_CBC_IDEA},
 431 #endif
 432 #ifndef OPENSSL_NO_SEED
 433     {"seed-cbc", D_CBC_SEED},
 434     {"seed", D_CBC_SEED},
 435 #endif
 436 #ifndef OPENSSL_NO_BF
 437     {"bf-cbc", D_CBC_BF},
 438     {"blowfish", D_CBC_BF},
 439     {"bf", D_CBC_BF},
 440 #endif
 441 #ifndef OPENSSL_NO_CAST
 442     {"cast-cbc", D_CBC_CAST},
 443     {"cast", D_CBC_CAST},
 444     {"cast5", D_CBC_CAST},
 445 #endif
 446     {"ghash", D_GHASH},
 447     {"rand", D_RAND}
 448 };
 449
 450 static double results[ALGOR_NUM][OSSL_NELEM(lengths_list)];
 451
 452 #ifndef OPENSSL_NO_DSA
 453 # define R_DSA_512       0
 454 # define R_DSA_1024      1
 455 # define R_DSA_2048      2
 456 static const OPT_PAIR dsa_choices[] = {
 457     {"dsa512", R_DSA_512},
 458     {"dsa1024", R_DSA_1024},
 459     {"dsa2048", R_DSA_2048}
 460 };
 461 # define DSA_NUM         OSSL_NELEM(dsa_choices)
 462
 463 static double dsa_results[DSA_NUM][2];  /* 2 ops: sign then verify */
 464 #endif  /* OPENSSL_NO_DSA */
 465
 466 #define R_RSA_512       0
 467 #define R_RSA_1024      1
 468 #define R_RSA_2048      2
 469 #define R_RSA_3072      3
 470 #define R_RSA_4096      4
 471 #define R_RSA_7680      5
 472 #define R_RSA_15360     6
 473 #ifndef OPENSSL_NO_RSA
 474 static const OPT_PAIR rsa_choices[] = {
 475     {"rsa512", R_RSA_512},
 476     {"rsa1024", R_RSA_1024},
 477     {"rsa2048", R_RSA_2048},
 478     {"rsa3072", R_RSA_3072},
 479     {"rsa4096", R_RSA_4096},
 480     {"rsa7680", R_RSA_7680},
 481     {"rsa15360", R_RSA_15360}
 482 };
 483 # define RSA_NUM OSSL_NELEM(rsa_choices)
 484
 485 static double rsa_results[RSA_NUM][2];  /* 2 ops: sign then verify */
 486 #endif /* OPENSSL_NO_RSA */
 487
 488 #define R_EC_P160    0
 489 #define R_EC_P192    1
 490 #define R_EC_P224    2
 491 #define R_EC_P256    3
 492 #define R_EC_P384    4
 493 #define R_EC_P521    5
 494 #define R_EC_K163    6
 495 #define R_EC_K233    7
 496 #define R_EC_K283    8
 497 #define R_EC_K409    9
 498 #define R_EC_K571    10
 499 #define R_EC_B163    11
 500 #define R_EC_B233    12
 501 #define R_EC_B283    13
 502 #define R_EC_B409    14
 503 #define R_EC_B571    15
 504 #define R_EC_BRP256R1  16
 505 #define R_EC_BRP256T1  17
 506 #define R_EC_BRP384R1  18
 507 #define R_EC_BRP384T1  19
 508 #define R_EC_BRP512R1  20
 509 #define R_EC_BRP512T1  21
 510 #define R_EC_X25519  22
 511 #define R_EC_X448    23
 512 #ifndef OPENSSL_NO_EC
 513 static OPT_PAIR ecdsa_choices[] = {
 514     {"ecdsap160", R_EC_P160},
 515     {"ecdsap192", R_EC_P192},
 516     {"ecdsap224", R_EC_P224},
 517     {"ecdsap256", R_EC_P256},
 518     {"ecdsap384", R_EC_P384},
 519     {"ecdsap521", R_EC_P521},
 520     {"ecdsak163", R_EC_K163},
 521     {"ecdsak233", R_EC_K233},
 522     {"ecdsak283", R_EC_K283},
 523     {"ecdsak409", R_EC_K409},
 524     {"ecdsak571", R_EC_K571},
 525     {"ecdsab163", R_EC_B163},
 526     {"ecdsab233", R_EC_B233},
 527     {"ecdsab283", R_EC_B283},
 528     {"ecdsab409", R_EC_B409},
 529     {"ecdsab571", R_EC_B571},
 530     {"ecdsabrp256r1", R_EC_BRP256R1},
 531     {"ecdsabrp256t1", R_EC_BRP256T1},
 532     {"ecdsabrp384r1", R_EC_BRP384R1},
 533     {"ecdsabrp384t1", R_EC_BRP384T1},
 534     {"ecdsabrp512r1", R_EC_BRP512R1},
 535     {"ecdsabrp512t1", R_EC_BRP512T1}
 536 };
 537 # define ECDSA_NUM       OSSL_NELEM(ecdsa_choices)
 538
 539 static double ecdsa_results[ECDSA_NUM][2];    /* 2 ops: sign then verify */
 540
 541 static const OPT_PAIR ecdh_choices[] = {
 542     {"ecdhp160", R_EC_P160},
 543     {"ecdhp192", R_EC_P192},
 544     {"ecdhp224", R_EC_P224},
 545     {"ecdhp256", R_EC_P256},
 546     {"ecdhp384", R_EC_P384},
 547     {"ecdhp521", R_EC_P521},
 548     {"ecdhk163", R_EC_K163},
 549     {"ecdhk233", R_EC_K233},
 550     {"ecdhk283", R_EC_K283},
 551     {"ecdhk409", R_EC_K409},
 552     {"ecdhk571", R_EC_K571},
 553     {"ecdhb163", R_EC_B163},
 554     {"ecdhb233", R_EC_B233},
 555     {"ecdhb283", R_EC_B283},
 556     {"ecdhb409", R_EC_B409},
 557     {"ecdhb571", R_EC_B571},
 558     {"ecdhbrp256r1", R_EC_BRP256R1},
 559     {"ecdhbrp256t1", R_EC_BRP256T1},
 560     {"ecdhbrp384r1", R_EC_BRP384R1},
 561     {"ecdhbrp384t1", R_EC_BRP384T1},
 562     {"ecdhbrp512r1", R_EC_BRP512R1},
 563     {"ecdhbrp512t1", R_EC_BRP512T1},
 564     {"ecdhx25519", R_EC_X25519},
 565     {"ecdhx448", R_EC_X448}
 566 };
 567 # define EC_NUM       OSSL_NELEM(ecdh_choices)
 568
 569 static double ecdh_results[EC_NUM][1];  /* 1 op: derivation */
 570 #endif /* OPENSSL_NO_EC */
 571
 572 #ifndef SIGALRM
 573 # define COND(d) (count < (d))
 574 # define COUNT(d) (d)
 575 #else
 576 # define COND(unused_cond) (run && count<0x7fffffff)
 577 # define COUNT(d) (count)
 578 #endif                          /* SIGALRM */
 579
 580 typedef struct loopargs_st {
 581     ASYNC_JOB *inprogress_job;
 582     ASYNC_WAIT_CTX *wait_ctx;
 583     unsigned char *buf;
 584     unsigned char *buf2;
 585     unsigned char *buf_malloc;
 586     unsigned char *buf2_malloc;
 587     unsigned char *key;
 588     unsigned int siglen;
 589 #ifndef OPENSSL_NO_RSA
 590     RSA *rsa_key[RSA_NUM];
 591 #endif
 592 #ifndef OPENSSL_NO_DSA
 593     DSA *dsa_key[DSA_NUM];
 594 #endif
 595 #ifndef OPENSSL_NO_EC
 596     EC_KEY *ecdsa[ECDSA_NUM];
 597     EVP_PKEY_CTX *ecdh_ctx[EC_NUM];
 598     unsigned char *secret_a;
 599     unsigned char *secret_b;
 600     size_t outlen[EC_NUM];
 601 #endif
 602     EVP_CIPHER_CTX *ctx;
 603     HMAC_CTX *hctx;
 604     GCM128_CONTEXT *gcm_ctx;
 605 } loopargs_t;
 606 static int run_benchmark(int async_jobs, int (*loop_function) (void *),
 607                          loopargs_t * loopargs);
 608
 609 static unsigned int testnum;
 610
 611 /* Nb of iterations to do per algorithm and key-size */
 612 static long c[ALGOR_NUM][OSSL_NELEM(lengths_list)];
 613
 614 #ifndef OPENSSL_NO_MD2
 615 static int EVP_Digest_MD2_loop(void *args)
 616 {
 617     loopargs_t *tempargs = *(loopargs_t **) args;
 618     unsigned char *buf = tempargs->buf;
 619     unsigned char md2[MD2_DIGEST_LENGTH];
 620     int count;
 621
 622     for (count = 0; COND(c[D_MD2][testnum]); count++) {
 623         if (!EVP_Digest(buf, (size_t)lengths[testnum], md2, NULL, EVP_md2(),
 624                         NULL))
 625             return -1;
 626     }
 627     return count;
 628 }
 629 #endif
 630
 631 #ifndef OPENSSL_NO_MDC2
 632 static int EVP_Digest_MDC2_loop(void *args)
 633 {
 634     loopargs_t *tempargs = *(loopargs_t **) args;
 635     unsigned char *buf = tempargs->buf;
 636     unsigned char mdc2[MDC2_DIGEST_LENGTH];
 637     int count;
 638
 639     for (count = 0; COND(c[D_MDC2][testnum]); count++) {
 640         if (!EVP_Digest(buf, (size_t)lengths[testnum], mdc2, NULL, EVP_mdc2(),
 641                         NULL))
 642             return -1;
 643     }
 644     return count;
 645 }
 646 #endif
 647
 648 #ifndef OPENSSL_NO_MD4
 649 static int EVP_Digest_MD4_loop(void *args)
 650 {
 651     loopargs_t *tempargs = *(loopargs_t **) args;
 652     unsigned char *buf = tempargs->buf;
 653     unsigned char md4[MD4_DIGEST_LENGTH];
 654     int count;
 655
 656     for (count = 0; COND(c[D_MD4][testnum]); count++) {
 657         if (!EVP_Digest(buf, (size_t)lengths[testnum], md4, NULL, EVP_md4(),
 658                         NULL))
 659             return -1;
 660     }
 661     return count;
 662 }
 663 #endif
 664
 665 #ifndef OPENSSL_NO_MD5
 666 static int MD5_loop(void *args)
 667 {
 668     loopargs_t *tempargs = *(loopargs_t **) args;
 669     unsigned char *buf = tempargs->buf;
 670     unsigned char md5[MD5_DIGEST_LENGTH];
 671     int count;
 672     for (count = 0; COND(c[D_MD5][testnum]); count++)
 673         MD5(buf, lengths[testnum], md5);
 674     return count;
 675 }
 676
 677 static int HMAC_loop(void *args)
 678 {
 679     loopargs_t *tempargs = *(loopargs_t **) args;
 680     unsigned char *buf = tempargs->buf;
 681     HMAC_CTX *hctx = tempargs->hctx;
 682     unsigned char hmac[MD5_DIGEST_LENGTH];
 683     int count;
 684
 685     for (count = 0; COND(c[D_HMAC][testnum]); count++) {
 686         HMAC_Init_ex(hctx, NULL, 0, NULL, NULL);
 687         HMAC_Update(hctx, buf, lengths[testnum]);
 688         HMAC_Final(hctx, hmac, NULL);
 689     }
 690     return count;
 691 }
 692 #endif
 693
 694 static int SHA1_loop(void *args)
 695 {
 696     loopargs_t *tempargs = *(loopargs_t **) args;
 697     unsigned char *buf = tempargs->buf;
 698     unsigned char sha[SHA_DIGEST_LENGTH];
 699     int count;
 700     for (count = 0; COND(c[D_SHA1][testnum]); count++)
 701         SHA1(buf, lengths[testnum], sha);
 702     return count;
 703 }
 704
 705 static int SHA256_loop(void *args)
 706 {
 707     loopargs_t *tempargs = *(loopargs_t **) args;
 708     unsigned char *buf = tempargs->buf;
 709     unsigned char sha256[SHA256_DIGEST_LENGTH];
 710     int count;
 711     for (count = 0; COND(c[D_SHA256][testnum]); count++)
 712         SHA256(buf, lengths[testnum], sha256);
 713     return count;
 714 }
 715
 716 static int SHA512_loop(void *args)
 717 {
 718     loopargs_t *tempargs = *(loopargs_t **) args;
 719     unsigned char *buf = tempargs->buf;
 720     unsigned char sha512[SHA512_DIGEST_LENGTH];
 721     int count;
 722     for (count = 0; COND(c[D_SHA512][testnum]); count++)
 723         SHA512(buf, lengths[testnum], sha512);
 724     return count;
 725 }
 726
 727 #ifndef OPENSSL_NO_WHIRLPOOL
 728 static int WHIRLPOOL_loop(void *args)
 729 {
 730     loopargs_t *tempargs = *(loopargs_t **) args;
 731     unsigned char *buf = tempargs->buf;
 732     unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];
 733     int count;
 734     for (count = 0; COND(c[D_WHIRLPOOL][testnum]); count++)
 735         WHIRLPOOL(buf, lengths[testnum], whirlpool);
 736     return count;
 737 }
 738 #endif
 739
 740 #ifndef OPENSSL_NO_RMD160
 741 static int EVP_Digest_RMD160_loop(void *args)
 742 {
 743     loopargs_t *tempargs = *(loopargs_t **) args;
 744     unsigned char *buf = tempargs->buf;
 745     unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
 746     int count;
 747     for (count = 0; COND(c[D_RMD160][testnum]); count++) {
 748         if (!EVP_Digest(buf, (size_t)lengths[testnum], &(rmd160[0]),
 749                         NULL, EVP_ripemd160(), NULL))
 750             return -1;
 751     }
 752     return count;
 753 }
 754 #endif
 755
 756 #ifndef OPENSSL_NO_RC4
 757 static RC4_KEY rc4_ks;
 758 static int RC4_loop(void *args)
 759 {
 760     loopargs_t *tempargs = *(loopargs_t **) args;
 761     unsigned char *buf = tempargs->buf;
 762     int count;
 763     for (count = 0; COND(c[D_RC4][testnum]); count++)
 764         RC4(&rc4_ks, (size_t)lengths[testnum], buf, buf);
 765     return count;
 766 }
 767 #endif
 768
 769 #ifndef OPENSSL_NO_DES
 770 static unsigned char DES_iv[8];
 771 static DES_key_schedule sch;
 772 static DES_key_schedule sch2;
 773 static DES_key_schedule sch3;
 774 static int DES_ncbc_encrypt_loop(void *args)
 775 {
 776     loopargs_t *tempargs = *(loopargs_t **) args;
 777     unsigned char *buf = tempargs->buf;
 778     int count;
 779     for (count = 0; COND(c[D_CBC_DES][testnum]); count++)
 780         DES_ncbc_encrypt(buf, buf, lengths[testnum], &sch,
 781                          &DES_iv, DES_ENCRYPT);
 782     return count;
 783 }
 784
 785 static int DES_ede3_cbc_encrypt_loop(void *args)
 786 {
 787     loopargs_t *tempargs = *(loopargs_t **) args;
 788     unsigned char *buf = tempargs->buf;
 789     int count;
 790     for (count = 0; COND(c[D_EDE3_DES][testnum]); count++)
 791         DES_ede3_cbc_encrypt(buf, buf, lengths[testnum],
 792                              &sch, &sch2, &sch3, &DES_iv, DES_ENCRYPT);
 793     return count;
 794 }
 795 #endif
 796
 797 #define MAX_BLOCK_SIZE 128
 798
 799 static unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
 800 static AES_KEY aes_ks1, aes_ks2, aes_ks3;
 801 static int AES_cbc_128_encrypt_loop(void *args)
 802 {
 803     loopargs_t *tempargs = *(loopargs_t **) args;
 804     unsigned char *buf = tempargs->buf;
 805     int count;
 806     for (count = 0; COND(c[D_CBC_128_AES][testnum]); count++)
 807         AES_cbc_encrypt(buf, buf,
 808                         (size_t)lengths[testnum], &aes_ks1, iv, AES_ENCRYPT);
 809     return count;
 810 }
 811
 812 static int AES_cbc_192_encrypt_loop(void *args)
 813 {
 814     loopargs_t *tempargs = *(loopargs_t **) args;
 815     unsigned char *buf = tempargs->buf;
 816     int count;
 817     for (count = 0; COND(c[D_CBC_192_AES][testnum]); count++)
 818         AES_cbc_encrypt(buf, buf,
 819                         (size_t)lengths[testnum], &aes_ks2, iv, AES_ENCRYPT);
 820     return count;
 821 }
 822
 823 static int AES_cbc_256_encrypt_loop(void *args)
 824 {
 825     loopargs_t *tempargs = *(loopargs_t **) args;
 826     unsigned char *buf = tempargs->buf;
 827     int count;
 828     for (count = 0; COND(c[D_CBC_256_AES][testnum]); count++)
 829         AES_cbc_encrypt(buf, buf,
 830                         (size_t)lengths[testnum], &aes_ks3, iv, AES_ENCRYPT);
 831     return count;
 832 }
 833
 834 static int AES_ige_128_encrypt_loop(void *args)
 835 {
 836     loopargs_t *tempargs = *(loopargs_t **) args;
 837     unsigned char *buf = tempargs->buf;
 838     unsigned char *buf2 = tempargs->buf2;
 839     int count;
 840     for (count = 0; COND(c[D_IGE_128_AES][testnum]); count++)
 841         AES_ige_encrypt(buf, buf2,
 842                         (size_t)lengths[testnum], &aes_ks1, iv, AES_ENCRYPT);
 843     return count;
 844 }
 845
 846 static int AES_ige_192_encrypt_loop(void *args)
 847 {
 848     loopargs_t *tempargs = *(loopargs_t **) args;
 849     unsigned char *buf = tempargs->buf;
 850     unsigned char *buf2 = tempargs->buf2;
 851     int count;
 852     for (count = 0; COND(c[D_IGE_192_AES][testnum]); count++)
 853         AES_ige_encrypt(buf, buf2,
 854                         (size_t)lengths[testnum], &aes_ks2, iv, AES_ENCRYPT);
 855     return count;
 856 }
 857
 858 static int AES_ige_256_encrypt_loop(void *args)
 859 {
 860     loopargs_t *tempargs = *(loopargs_t **) args;
 861     unsigned char *buf = tempargs->buf;
 862     unsigned char *buf2 = tempargs->buf2;
 863     int count;
 864     for (count = 0; COND(c[D_IGE_256_AES][testnum]); count++)
 865         AES_ige_encrypt(buf, buf2,
 866                         (size_t)lengths[testnum], &aes_ks3, iv, AES_ENCRYPT);
 867     return count;
 868 }
 869
 870 static int CRYPTO_gcm128_aad_loop(void *args)
 871 {
 872     loopargs_t *tempargs = *(loopargs_t **) args;
 873     unsigned char *buf = tempargs->buf;
 874     GCM128_CONTEXT *gcm_ctx = tempargs->gcm_ctx;
 875     int count;
 876     for (count = 0; COND(c[D_GHASH][testnum]); count++)
 877         CRYPTO_gcm128_aad(gcm_ctx, buf, lengths[testnum]);
 878     return count;
 879 }
 880
 881 static int RAND_bytes_loop(void *args)
 882 {
 883     loopargs_t *tempargs = *(loopargs_t **) args;
 884     unsigned char *buf = tempargs->buf;
 885     int count;
 886
 887     for (count = 0; COND(c[D_RAND][testnum]); count++)
 888         RAND_bytes(buf, lengths[testnum]);
 889     return count;
 890 }
 891
 892 static long save_count = 0;
 893 static int decrypt = 0;
 894 static int EVP_Update_loop(void *args)
 895 {
 896     loopargs_t *tempargs = *(loopargs_t **) args;
 897     unsigned char *buf = tempargs->buf;
 898     EVP_CIPHER_CTX *ctx = tempargs->ctx;
 899     int outl, count, rc;
 900 #ifndef SIGALRM
 901     int nb_iter = save_count * 4 * lengths[0] / lengths[testnum];
 902 #endif
 903     if (decrypt) {
 904         for (count = 0; COND(nb_iter); count++) {
 905             rc = EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
 906             if (rc != 1)
 907                 EVP_CipherInit_ex(ctx, NULL, NULL, NULL, iv, -1);
 908         }
 909     } else {
 910         for (count = 0; COND(nb_iter); count++) {
 911             rc = EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
 912             if (rc != 1)
 913                 EVP_CipherInit_ex(ctx, NULL, NULL, NULL, iv, -1);
 914         }
 915     }
 916     if (decrypt)
 917         EVP_DecryptFinal_ex(ctx, buf, &outl);
 918     else
 919         EVP_EncryptFinal_ex(ctx, buf, &outl);
 920     return count;
 921 }
 922
 923 /*
 924  * CCM does not support streaming. For the purpose of performance measurement,
 925  * each message is encrypted using the same (key,iv)-pair. Do not use this
 926  * code in your application.
 927  */
 928 static int EVP_Update_loop_ccm(void *args)
 929 {
 930     loopargs_t *tempargs = *(loopargs_t **) args;
 931     unsigned char *buf = tempargs->buf;
 932     EVP_CIPHER_CTX *ctx = tempargs->ctx;
 933     int outl, count;
 934     unsigned char tag[12];
 935 #ifndef SIGALRM
 936     int nb_iter = save_count * 4 * lengths[0] / lengths[testnum];
 937 #endif
 938     if (decrypt) {
 939         for (count = 0; COND(nb_iter); count++) {
 940             EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, iv);
 941             EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, sizeof(tag), tag);
 942             EVP_DecryptUpdate(ctx, NULL, &outl, NULL, lengths[testnum]);
 943             EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
 944             EVP_DecryptFinal_ex(ctx, buf, &outl);
 945         }
 946     } else {
 947         for (count = 0; COND(nb_iter); count++) {
 948             EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv);
 949             EVP_EncryptUpdate(ctx, NULL, &outl, NULL, lengths[testnum]);
 950             EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
 951             EVP_EncryptFinal_ex(ctx, buf, &outl);
 952         }
 953     }
 954     return count;
 955 }
 956
 957 /*
 958  * To make AEAD benchmarking more relevant perform TLS-like operations,
 959  * 13-byte AAD followed by payload. But don't use TLS-formatted AAD, as
 960  * payload length is not actually limited by 16KB...
 961  */
 962 static int EVP_Update_loop_aead(void *args)
 963 {
 964     loopargs_t *tempargs = *(loopargs_t **) args;
 965     unsigned char *buf = tempargs->buf;
 966     EVP_CIPHER_CTX *ctx = tempargs->ctx;
 967     int outl, count;
 968     unsigned char aad[13] = { 0xcc };
 969     unsigned char faketag[16] = { 0xcc };
 970 #ifndef SIGALRM
 971     int nb_iter = save_count * 4 * lengths[0] / lengths[testnum];
 972 #endif
 973     if (decrypt) {
 974         for (count = 0; COND(nb_iter); count++) {
 975             EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, iv);
 976             EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
 977                                 sizeof(faketag), faketag);
 978             EVP_DecryptUpdate(ctx, NULL, &outl, aad, sizeof(aad));
 979             EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
 980             EVP_DecryptFinal_ex(ctx, buf + outl, &outl);
 981         }
 982     } else {
 983         for (count = 0; COND(nb_iter); count++) {
 984             EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv);
 985             EVP_EncryptUpdate(ctx, NULL, &outl, aad, sizeof(aad));
 986             EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
 987             EVP_EncryptFinal_ex(ctx, buf + outl, &outl);
 988         }
 989     }
 990     return count;
 991 }
 992
 993 static const EVP_MD *evp_md = NULL;
 994 static int EVP_Digest_loop(void *args)
 995 {
 996     loopargs_t *tempargs = *(loopargs_t **) args;
 997     unsigned char *buf = tempargs->buf;
 998     unsigned char md[EVP_MAX_MD_SIZE];
 999     int count;
1000 #ifndef SIGALRM
1001     int nb_iter = save_count * 4 * lengths[0] / lengths[testnum];
1002 #endif
1003
1004     for (count = 0; COND(nb_iter); count++) {
1005         if (!EVP_Digest(buf, lengths[testnum], md, NULL, evp_md, NULL))
1006             return -1;
1007     }
1008     return count;
1009 }
1010
1011 #ifndef OPENSSL_NO_RSA
1012 static long rsa_c[RSA_NUM][2];  /* # RSA iteration test */
1013
1014 static int RSA_sign_loop(void *args)
1015 {
1016     loopargs_t *tempargs = *(loopargs_t **) args;
1017     unsigned char *buf = tempargs->buf;
1018     unsigned char *buf2 = tempargs->buf2;
1019     unsigned int *rsa_num = &tempargs->siglen;
1020     RSA **rsa_key = tempargs->rsa_key;
1021     int ret, count;
1022     for (count = 0; COND(rsa_c[testnum][0]); count++) {
1023         ret = RSA_sign(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
1024         if (ret == 0) {
1025             BIO_printf(bio_err, "RSA sign failure\n");
1026             ERR_print_errors(bio_err);
1027             count = -1;
1028             break;
1029         }
1030     }
1031     return count;
1032 }
1033
1034 static int RSA_verify_loop(void *args)
1035 {
1036     loopargs_t *tempargs = *(loopargs_t **) args;
1037     unsigned char *buf = tempargs->buf;
1038     unsigned char *buf2 = tempargs->buf2;
1039     unsigned int rsa_num = tempargs->siglen;
1040     RSA **rsa_key = tempargs->rsa_key;
1041     int ret, count;
1042     for (count = 0; COND(rsa_c[testnum][1]); count++) {
1043         ret =
1044             RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
1045         if (ret <= 0) {
1046             BIO_printf(bio_err, "RSA verify failure\n");
1047             ERR_print_errors(bio_err);
1048             count = -1;
1049             break;
1050         }
1051     }
1052     return count;
1053 }
1054 #endif
1055
1056 #ifndef OPENSSL_NO_DSA
1057 static long dsa_c[DSA_NUM][2];
1058 static int DSA_sign_loop(void *args)
1059 {
1060     loopargs_t *tempargs = *(loopargs_t **) args;
1061     unsigned char *buf = tempargs->buf;
1062     unsigned char *buf2 = tempargs->buf2;
1063     DSA **dsa_key = tempargs->dsa_key;
1064     unsigned int *siglen = &tempargs->siglen;
1065     int ret, count;
1066     for (count = 0; COND(dsa_c[testnum][0]); count++) {
1067         ret = DSA_sign(0, buf, 20, buf2, siglen, dsa_key[testnum]);
1068         if (ret == 0) {
1069             BIO_printf(bio_err, "DSA sign failure\n");
1070             ERR_print_errors(bio_err);
1071             count = -1;
1072             break;
1073         }
1074     }
1075     return count;
1076 }
1077
1078 static int DSA_verify_loop(void *args)
1079 {
1080     loopargs_t *tempargs = *(loopargs_t **) args;
1081     unsigned char *buf = tempargs->buf;
1082     unsigned char *buf2 = tempargs->buf2;
1083     DSA **dsa_key = tempargs->dsa_key;
1084     unsigned int siglen = tempargs->siglen;
1085     int ret, count;
1086     for (count = 0; COND(dsa_c[testnum][1]); count++) {
1087         ret = DSA_verify(0, buf, 20, buf2, siglen, dsa_key[testnum]);
1088         if (ret <= 0) {
1089             BIO_printf(bio_err, "DSA verify failure\n");
1090             ERR_print_errors(bio_err);
1091             count = -1;
1092             break;
1093         }
1094     }
1095     return count;
1096 }
1097 #endif
1098
1099 #ifndef OPENSSL_NO_EC
1100 static long ecdsa_c[ECDSA_NUM][2];
1101 static int ECDSA_sign_loop(void *args)
1102 {
1103     loopargs_t *tempargs = *(loopargs_t **) args;
1104     unsigned char *buf = tempargs->buf;
1105     EC_KEY **ecdsa = tempargs->ecdsa;
1106     unsigned char *ecdsasig = tempargs->buf2;
1107     unsigned int *ecdsasiglen = &tempargs->siglen;
1108     int ret, count;
1109     for (count = 0; COND(ecdsa_c[testnum][0]); count++) {
1110         ret = ECDSA_sign(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[testnum]);
1111         if (ret == 0) {
1112             BIO_printf(bio_err, "ECDSA sign failure\n");
1113             ERR_print_errors(bio_err);
1114             count = -1;
1115             break;
1116         }
1117     }
1118     return count;
1119 }
1120
1121 static int ECDSA_verify_loop(void *args)
1122 {
1123     loopargs_t *tempargs = *(loopargs_t **) args;
1124     unsigned char *buf = tempargs->buf;
1125     EC_KEY **ecdsa = tempargs->ecdsa;
1126     unsigned char *ecdsasig = tempargs->buf2;
1127     unsigned int ecdsasiglen = tempargs->siglen;
1128     int ret, count;
1129     for (count = 0; COND(ecdsa_c[testnum][1]); count++) {
1130         ret = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[testnum]);
1131         if (ret != 1) {
1132             BIO_printf(bio_err, "ECDSA verify failure\n");
1133             ERR_print_errors(bio_err);
1134             count = -1;
1135             break;
1136         }
1137     }
1138     return count;
1139 }
1140
1141 /* ******************************************************************** */
1142 static long ecdh_c[EC_NUM][1];
1143
1144 static int ECDH_EVP_derive_key_loop(void *args)
1145 {
1146     loopargs_t *tempargs = *(loopargs_t **) args;
1147     EVP_PKEY_CTX *ctx = tempargs->ecdh_ctx[testnum];
1148     unsigned char *derived_secret = tempargs->secret_a;
1149     int count;
1150     size_t *outlen = &(tempargs->outlen[testnum]);
1151
1152     for (count = 0; COND(ecdh_c[testnum][0]); count++)
1153         EVP_PKEY_derive(ctx, derived_secret, outlen);
1154
1155     return count;
1156 }
1157
1158 #endif                          /* OPENSSL_NO_EC */
1159
1160 static int run_benchmark(int async_jobs,
1161                          int (*loop_function) (void *), loopargs_t * loopargs)
1162 {
1163     int job_op_count = 0;
1164     int total_op_count = 0;
1165     int num_inprogress = 0;
1166     int error = 0, i = 0, ret = 0;
1167     OSSL_ASYNC_FD job_fd = 0;
1168     size_t num_job_fds = 0;
1169
1170     run = 1;
1171
1172     if (async_jobs == 0) {
1173         return loop_function((void *)&loopargs);
1174     }
1175
1176     for (i = 0; i < async_jobs && !error; i++) {
1177         loopargs_t *looparg_item = loopargs + i;
1178
1179         /* Copy pointer content (looparg_t item address) into async context */
1180         ret = ASYNC_start_job(&loopargs[i].inprogress_job, loopargs[i].wait_ctx,
1181                               &job_op_count, loop_function,
1182                               (void *)&looparg_item, sizeof(looparg_item));
1183         switch (ret) {
1184         case ASYNC_PAUSE:
1185             ++num_inprogress;
1186             break;
1187         case ASYNC_FINISH:
1188             if (job_op_count == -1) {
1189                 error = 1;
1190             } else {
1191                 total_op_count += job_op_count;
1192             }
1193             break;
1194         case ASYNC_NO_JOBS:
1195         case ASYNC_ERR:
1196             BIO_printf(bio_err, "Failure in the job\n");
1197             ERR_print_errors(bio_err);
1198             error = 1;
1199             break;
1200         }
1201     }
1202
1203     while (num_inprogress > 0) {
1204 #if defined(OPENSSL_SYS_WINDOWS)
1205         DWORD avail = 0;
1206 #elif defined(OPENSSL_SYS_UNIX)
1207         int select_result = 0;
1208         OSSL_ASYNC_FD max_fd = 0;
1209         fd_set waitfdset;
1210
1211         FD_ZERO(&waitfdset);
1212
1213         for (i = 0; i < async_jobs && num_inprogress > 0; i++) {
1214             if (loopargs[i].inprogress_job == NULL)
1215                 continue;
1216
1217             if (!ASYNC_WAIT_CTX_get_all_fds
1218                 (loopargs[i].wait_ctx, NULL, &num_job_fds)
1219                 || num_job_fds > 1) {
1220                 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1221                 ERR_print_errors(bio_err);
1222                 error = 1;
1223                 break;
1224             }
1225             ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd,
1226                                        &num_job_fds);
1227             FD_SET(job_fd, &waitfdset);
1228             if (job_fd > max_fd)
1229                 max_fd = job_fd;
1230         }
1231
1232         if (max_fd >= (OSSL_ASYNC_FD)FD_SETSIZE) {
1233             BIO_printf(bio_err,
1234                        "Error: max_fd (%d) must be smaller than FD_SETSIZE (%d). "
1235                        "Decrease the value of async_jobs\n",
1236                        max_fd, FD_SETSIZE);
1237             ERR_print_errors(bio_err);
1238             error = 1;
1239             break;
1240         }
1241
1242         select_result = select(max_fd + 1, &waitfdset, NULL, NULL, NULL);
1243         if (select_result == -1 && errno == EINTR)
1244             continue;
1245
1246         if (select_result == -1) {
1247             BIO_printf(bio_err, "Failure in the select\n");
1248             ERR_print_errors(bio_err);
1249             error = 1;
1250             break;
1251         }
1252
1253         if (select_result == 0)
1254             continue;
1255 #endif
1256
1257         for (i = 0; i < async_jobs; i++) {
1258             if (loopargs[i].inprogress_job == NULL)
1259                 continue;
1260
1261             if (!ASYNC_WAIT_CTX_get_all_fds
1262                 (loopargs[i].wait_ctx, NULL, &num_job_fds)
1263                 || num_job_fds > 1) {
1264                 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1265                 ERR_print_errors(bio_err);
1266                 error = 1;
1267                 break;
1268             }
1269             ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd,
1270                                        &num_job_fds);
1271
1272 #if defined(OPENSSL_SYS_UNIX)
1273             if (num_job_fds == 1 && !FD_ISSET(job_fd, &waitfdset))
1274                 continue;
1275 #elif defined(OPENSSL_SYS_WINDOWS)
1276             if (num_job_fds == 1
1277                 && !PeekNamedPipe(job_fd, NULL, 0, NULL, &avail, NULL)
1278                 && avail > 0)
1279                 continue;
1280 #endif
1281
1282             ret = ASYNC_start_job(&loopargs[i].inprogress_job,
1283                                   loopargs[i].wait_ctx, &job_op_count,
1284                                   loop_function, (void *)(loopargs + i),
1285                                   sizeof(loopargs_t));
1286             switch (ret) {
1287             case ASYNC_PAUSE:
1288                 break;
1289             case ASYNC_FINISH:
1290                 if (job_op_count == -1) {
1291                     error = 1;
1292                 } else {
1293                     total_op_count += job_op_count;
1294                 }
1295                 --num_inprogress;
1296                 loopargs[i].inprogress_job = NULL;
1297                 break;
1298             case ASYNC_NO_JOBS:
1299             case ASYNC_ERR:
1300                 --num_inprogress;
1301                 loopargs[i].inprogress_job = NULL;
1302                 BIO_printf(bio_err, "Failure in the job\n");
1303                 ERR_print_errors(bio_err);
1304                 error = 1;
1305                 break;
1306             }
1307         }
1308     }
1309
1310     return error ? -1 : total_op_count;
1311 }
1312
1313 int speed_main(int argc, char **argv)
1314 {
1315     ENGINE *e = NULL;
1316     loopargs_t *loopargs = NULL;
1317     const char *prog;
1318     const char *engine_id = NULL;
1319     const EVP_CIPHER *evp_cipher = NULL;
1320     double d = 0.0;
1321     OPTION_CHOICE o;
1322     int async_init = 0, multiblock = 0, pr_header = 0;
1323     int doit[ALGOR_NUM] = { 0 };
1324     int ret = 1, misalign = 0, lengths_single = 0, aead = 0;
1325     long count = 0;
1326     unsigned int size_num = OSSL_NELEM(lengths_list);
1327     unsigned int i, k, loop, loopargs_len = 0, async_jobs = 0;
1328     int keylen;
1329     int buflen;
1330 #ifndef NO_FORK
1331     int multi = 0;
1332 #endif
1333 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) \
1334     || !defined(OPENSSL_NO_EC)
1335     long rsa_count = 1;
1336 #endif
1337     openssl_speed_sec_t seconds = { SECONDS, RSA_SECONDS, DSA_SECONDS,
1338                                     ECDSA_SECONDS, ECDH_SECONDS };
1339
1340     /* What follows are the buffers and key material. */
1341 #ifndef OPENSSL_NO_RC5
1342     RC5_32_KEY rc5_ks;
1343 #endif
1344 #ifndef OPENSSL_NO_RC2
1345     RC2_KEY rc2_ks;
1346 #endif
1347 #ifndef OPENSSL_NO_IDEA
1348     IDEA_KEY_SCHEDULE idea_ks;
1349 #endif
1350 #ifndef OPENSSL_NO_SEED
1351     SEED_KEY_SCHEDULE seed_ks;
1352 #endif
1353 #ifndef OPENSSL_NO_BF
1354     BF_KEY bf_ks;
1355 #endif
1356 #ifndef OPENSSL_NO_CAST
1357     CAST_KEY cast_ks;
1358 #endif
1359     static const unsigned char key16[16] = {
1360         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1361         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1362     };
1363     static const unsigned char key24[24] = {
1364         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1365         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1366         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1367     };
1368     static const unsigned char key32[32] = {
1369         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1370         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1371         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1372         0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1373     };
1374 #ifndef OPENSSL_NO_CAMELLIA
1375     static const unsigned char ckey24[24] = {
1376         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1377         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1378         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1379     };
1380     static const unsigned char ckey32[32] = {
1381         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1382         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1383         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1384         0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1385     };
1386     CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
1387 #endif
1388 #ifndef OPENSSL_NO_DES
1389     static DES_cblock key = {
1390         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
1391     };
1392     static DES_cblock key2 = {
1393         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1394     };
1395     static DES_cblock key3 = {
1396         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1397     };
1398 #endif
1399 #ifndef OPENSSL_NO_RSA
1400     static const unsigned int rsa_bits[RSA_NUM] = {
1401         512, 1024, 2048, 3072, 4096, 7680, 15360
1402     };
1403     static const unsigned char *rsa_data[RSA_NUM] = {
1404         test512, test1024, test2048, test3072, test4096, test7680, test15360
1405     };
1406     static const int rsa_data_length[RSA_NUM] = {
1407         sizeof(test512), sizeof(test1024),
1408         sizeof(test2048), sizeof(test3072),
1409         sizeof(test4096), sizeof(test7680),
1410         sizeof(test15360)
1411     };
1412     int rsa_doit[RSA_NUM] = { 0 };
1413     int primes = RSA_DEFAULT_PRIME_NUM;
1414 #endif
1415 #ifndef OPENSSL_NO_DSA
1416     static const unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
1417     int dsa_doit[DSA_NUM] = { 0 };
1418 #endif
1419 #ifndef OPENSSL_NO_EC
1420     /*
1421      * We only test over the following curves as they are representative, To
1422      * add tests over more curves, simply add the curve NID and curve name to
1423      * the following arrays and increase the |ecdh_choices| list accordingly.
1424      */
1425     static const struct {
1426         const char *name;
1427         unsigned int nid;
1428         unsigned int bits;
1429     } test_curves[] = {
1430         /* Prime Curves */
1431         {"secp160r1", NID_secp160r1, 160},
1432         {"nistp192", NID_X9_62_prime192v1, 192},
1433         {"nistp224", NID_secp224r1, 224},
1434         {"nistp256", NID_X9_62_prime256v1, 256},
1435         {"nistp384", NID_secp384r1, 384},
1436         {"nistp521", NID_secp521r1, 521},
1437         /* Binary Curves */
1438         {"nistk163", NID_sect163k1, 163},
1439         {"nistk233", NID_sect233k1, 233},
1440         {"nistk283", NID_sect283k1, 283},
1441         {"nistk409", NID_sect409k1, 409},
1442         {"nistk571", NID_sect571k1, 571},
1443         {"nistb163", NID_sect163r2, 163},
1444         {"nistb233", NID_sect233r1, 233},
1445         {"nistb283", NID_sect283r1, 283},
1446         {"nistb409", NID_sect409r1, 409},
1447         {"nistb571", NID_sect571r1, 571},
1448         {"brainpoolP256r1", NID_brainpoolP256r1, 256},
1449         {"brainpoolP256t1", NID_brainpoolP256t1, 256},
1450         {"brainpoolP384r1", NID_brainpoolP384r1, 384},
1451         {"brainpoolP384t1", NID_brainpoolP384t1, 384},
1452         {"brainpoolP512r1", NID_brainpoolP512r1, 512},
1453         {"brainpoolP512t1", NID_brainpoolP512t1, 512},
1454         /* Other and ECDH only ones */
1455         {"X25519", NID_X25519, 253},
1456         {"X448", NID_X448, 448}
1457     };
1458     int ecdsa_doit[ECDSA_NUM] = { 0 };
1459     int ecdh_doit[EC_NUM] = { 0 };
1460     OPENSSL_assert(OSSL_NELEM(test_curves) >= EC_NUM);
1461 #endif                          /* ndef OPENSSL_NO_EC */
1462
1463     prog = opt_init(argc, argv, speed_options);
1464     while ((o = opt_next()) != OPT_EOF) {
1465         switch (o) {
1466         case OPT_EOF:
1467         case OPT_ERR:
1468  opterr:
1469             BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
1470             goto end;
1471         case OPT_HELP:
1472             opt_help(speed_options);
1473             ret = 0;
1474             goto end;
1475         case OPT_ELAPSED:
1476             usertime = 0;
1477             break;
1478         case OPT_EVP:
1479             evp_md = NULL;
1480             evp_cipher = EVP_get_cipherbyname(opt_arg());
1481             if (evp_cipher == NULL)
1482                 evp_md = EVP_get_digestbyname(opt_arg());
1483             if (evp_cipher == NULL && evp_md == NULL) {
1484                 BIO_printf(bio_err,
1485                            "%s: %s is an unknown cipher or digest\n",
1486                            prog, opt_arg());
1487                 goto end;
1488             }
1489             doit[D_EVP] = 1;
1490             break;
1491         case OPT_DECRYPT:
1492             decrypt = 1;
1493             break;
1494         case OPT_ENGINE:
1495             /*
1496              * In a forked execution, an engine might need to be
1497              * initialised by each child process, not by the parent.
1498              * So store the name here and run setup_engine() later on.
1499              */
1500             engine_id = opt_arg();
1501             break;
1502         case OPT_MULTI:
1503 #ifndef NO_FORK
1504             multi = atoi(opt_arg());
1505 #endif
1506             break;
1507         case OPT_ASYNCJOBS:
1508 #ifndef OPENSSL_NO_ASYNC
1509             async_jobs = atoi(opt_arg());
1510             if (!ASYNC_is_capable()) {
1511                 BIO_printf(bio_err,
1512                            "%s: async_jobs specified but async not supported\n",
1513                            prog);
1514                 goto opterr;
1515             }
1516             if (async_jobs > 99999) {
1517                 BIO_printf(bio_err, "%s: too many async_jobs\n", prog);
1518                 goto opterr;
1519             }
1520 #endif
1521             break;
1522         case OPT_MISALIGN:
1523             if (!opt_int(opt_arg(), &misalign))
1524                 goto end;
1525             if (misalign > MISALIGN) {
1526                 BIO_printf(bio_err,
1527                            "%s: Maximum offset is %d\n", prog, MISALIGN);
1528                 goto opterr;
1529             }
1530             break;
1531         case OPT_MR:
1532             mr = 1;
1533             break;
1534         case OPT_MB:
1535             multiblock = 1;
1536 #ifdef OPENSSL_NO_MULTIBLOCK
1537             BIO_printf(bio_err,
1538                        "%s: -mb specified but multi-block support is disabled\n",
1539                        prog);
1540             goto end;
1541 #endif
1542             break;
1543         case OPT_R_CASES:
1544             if (!opt_rand(o))
1545                 goto end;
1546             break;
1547         case OPT_PRIMES:
1548             if (!opt_int(opt_arg(), &primes))
1549                 goto end;
1550             break;
1551         case OPT_SECONDS:
1552             seconds.sym = seconds.rsa = seconds.dsa = seconds.ecdsa
1553                         = seconds.ecdh = atoi(opt_arg());
1554             break;
1555         case OPT_BYTES:
1556             lengths_single = atoi(opt_arg());
1557             lengths = &lengths_single;
1558             size_num = 1;
1559             break;
1560         case OPT_AEAD:
1561             aead = 1;
1562             break;
1563         }
1564     }
1565     argc = opt_num_rest();
1566     argv = opt_rest();
1567
1568     /* Remaining arguments are algorithms. */
1569     for (; *argv; argv++) {
1570         if (found(*argv, doit_choices, &i)) {
1571             doit[i] = 1;
1572             continue;
1573         }
1574 #ifndef OPENSSL_NO_DES
1575         if (strcmp(*argv, "des") == 0) {
1576             doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
1577             continue;
1578         }
1579 #endif
1580         if (strcmp(*argv, "sha") == 0) {
1581             doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
1582             continue;
1583         }
1584 #ifndef OPENSSL_NO_RSA
1585         if (strcmp(*argv, "openssl") == 0)
1586             continue;
1587         if (strcmp(*argv, "rsa") == 0) {
1588             for (loop = 0; loop < OSSL_NELEM(rsa_doit); loop++)
1589                 rsa_doit[loop] = 1;
1590             continue;
1591         }
1592         if (found(*argv, rsa_choices, &i)) {
1593             rsa_doit[i] = 1;
1594             continue;
1595         }
1596 #endif
1597 #ifndef OPENSSL_NO_DSA
1598         if (strcmp(*argv, "dsa") == 0) {
1599             dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
1600                 dsa_doit[R_DSA_2048] = 1;
1601             continue;
1602         }
1603         if (found(*argv, dsa_choices, &i)) {
1604             dsa_doit[i] = 2;
1605             continue;
1606         }
1607 #endif
1608         if (strcmp(*argv, "aes") == 0) {
1609             doit[D_CBC_128_AES] = doit[D_CBC_192_AES] = doit[D_CBC_256_AES] = 1;
1610             continue;
1611         }
1612 #ifndef OPENSSL_NO_CAMELLIA
1613         if (strcmp(*argv, "camellia") == 0) {
1614             doit[D_CBC_128_CML] = doit[D_CBC_192_CML] = doit[D_CBC_256_CML] = 1;
1615             continue;
1616         }
1617 #endif
1618 #ifndef OPENSSL_NO_EC
1619         if (strcmp(*argv, "ecdsa") == 0) {
1620             for (loop = 0; loop < OSSL_NELEM(ecdsa_doit); loop++)
1621                 ecdsa_doit[loop] = 1;
1622             continue;
1623         }
1624         if (found(*argv, ecdsa_choices, &i)) {
1625             ecdsa_doit[i] = 2;
1626             continue;
1627         }
1628         if (strcmp(*argv, "ecdh") == 0) {
1629             for (loop = 0; loop < OSSL_NELEM(ecdh_doit); loop++)
1630                 ecdh_doit[loop] = 1;
1631             continue;
1632         }
1633         if (found(*argv, ecdh_choices, &i)) {
1634             ecdh_doit[i] = 2;
1635             continue;
1636         }
1637 #endif
1638         BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
1639         goto end;
1640     }
1641
1642     /* Sanity checks */
1643     if (aead) {
1644         if (evp_cipher == NULL) {
1645             BIO_printf(bio_err, "-aead can be used only with an AEAD cipher\n");
1646             goto end;
1647         } else if (!(EVP_CIPHER_flags(evp_cipher) &
1648                      EVP_CIPH_FLAG_AEAD_CIPHER)) {
1649             BIO_printf(bio_err, "%s is not an AEAD cipher\n",
1650                        OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
1651             goto end;
1652         }
1653     }
1654     if (multiblock) {
1655         if (evp_cipher == NULL) {
1656             BIO_printf(bio_err,"-mb can be used only with a multi-block"
1657                                " capable cipher\n");
1658             goto end;
1659         } else if (!(EVP_CIPHER_flags(evp_cipher) &
1660                      EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
1661             BIO_printf(bio_err, "%s is not a multi-block capable\n",
1662                        OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
1663             goto end;
1664         } else if (async_jobs > 0) {
1665             BIO_printf(bio_err, "Async mode is not supported with -mb");
1666             goto end;
1667         }
1668     }
1669
1670     /* Initialize the job pool if async mode is enabled */
1671     if (async_jobs > 0) {
1672         async_init = ASYNC_init_thread(async_jobs, async_jobs);
1673         if (!async_init) {
1674             BIO_printf(bio_err, "Error creating the ASYNC job pool\n");
1675             goto end;
1676         }
1677     }
1678
1679     loopargs_len = (async_jobs == 0 ? 1 : async_jobs);
1680     loopargs =
1681         app_malloc(loopargs_len * sizeof(loopargs_t), "array of loopargs");
1682     memset(loopargs, 0, loopargs_len * sizeof(loopargs_t));
1683
1684     for (i = 0; i < loopargs_len; i++) {
1685         if (async_jobs > 0) {
1686             loopargs[i].wait_ctx = ASYNC_WAIT_CTX_new();
1687             if (loopargs[i].wait_ctx == NULL) {
1688                 BIO_printf(bio_err, "Error creating the ASYNC_WAIT_CTX\n");
1689                 goto end;
1690             }
1691         }
1692
1693         buflen = lengths[size_num - 1];
1694         if (buflen < 36)    /* size of random vector in RSA bencmark */
1695             buflen = 36;
1696         buflen += MAX_MISALIGNMENT + 1;
1697         loopargs[i].buf_malloc = app_malloc(buflen, "input buffer");
1698         loopargs[i].buf2_malloc = app_malloc(buflen, "input buffer");
1699         memset(loopargs[i].buf_malloc, 0, buflen);
1700         memset(loopargs[i].buf2_malloc, 0, buflen);
1701
1702         /* Align the start of buffers on a 64 byte boundary */
1703         loopargs[i].buf = loopargs[i].buf_malloc + misalign;
1704         loopargs[i].buf2 = loopargs[i].buf2_malloc + misalign;
1705 #ifndef OPENSSL_NO_EC
1706         loopargs[i].secret_a = app_malloc(MAX_ECDH_SIZE, "ECDH secret a");
1707         loopargs[i].secret_b = app_malloc(MAX_ECDH_SIZE, "ECDH secret b");
1708 #endif
1709     }
1710
1711 #ifndef NO_FORK
1712     if (multi && do_multi(multi, size_num))
1713         goto show_res;
1714 #endif
1715
1716     /* Initialize the engine after the fork */
1717     e = setup_engine(engine_id, 0);
1718
1719     /* No parameters; turn on everything. */
1720     if ((argc == 0) && !doit[D_EVP]) {
1721         for (i = 0; i < ALGOR_NUM; i++)
1722             if (i != D_EVP)
1723                 doit[i] = 1;
1724 #ifndef OPENSSL_NO_RSA
1725         for (i = 0; i < RSA_NUM; i++)
1726             rsa_doit[i] = 1;
1727 #endif
1728 #ifndef OPENSSL_NO_DSA
1729         for (i = 0; i < DSA_NUM; i++)
1730             dsa_doit[i] = 1;
1731 #endif
1732 #ifndef OPENSSL_NO_EC
1733         for (loop = 0; loop < OSSL_NELEM(ecdsa_doit); loop++)
1734             ecdsa_doit[loop] = 1;
1735         for (loop = 0; loop < OSSL_NELEM(ecdh_doit); loop++)
1736             ecdh_doit[loop] = 1;
1737 #endif
1738     }
1739     for (i = 0; i < ALGOR_NUM; i++)
1740         if (doit[i])
1741             pr_header++;
1742
1743     if (usertime == 0 && !mr)
1744         BIO_printf(bio_err,
1745                    "You have chosen to measure elapsed time "
1746                    "instead of user CPU time.\n");
1747
1748 #ifndef OPENSSL_NO_RSA
1749     for (i = 0; i < loopargs_len; i++) {
1750         if (primes > RSA_DEFAULT_PRIME_NUM) {
1751             /* for multi-prime RSA, skip this */
1752             break;
1753         }
1754         for (k = 0; k < RSA_NUM; k++) {
1755             const unsigned char *p;
1756
1757             p = rsa_data[k];
1758             loopargs[i].rsa_key[k] =
1759                 d2i_RSAPrivateKey(NULL, &p, rsa_data_length[k]);
1760             if (loopargs[i].rsa_key[k] == NULL) {
1761                 BIO_printf(bio_err,
1762                            "internal error loading RSA key number %d\n", k);
1763                 goto end;
1764             }
1765         }
1766     }
1767 #endif
1768 #ifndef OPENSSL_NO_DSA
1769     for (i = 0; i < loopargs_len; i++) {
1770         loopargs[i].dsa_key[0] = get_dsa(512);
1771         loopargs[i].dsa_key[1] = get_dsa(1024);
1772         loopargs[i].dsa_key[2] = get_dsa(2048);
1773     }
1774 #endif
1775 #ifndef OPENSSL_NO_DES
1776     DES_set_key_unchecked(&key, &sch);
1777     DES_set_key_unchecked(&key2, &sch2);
1778     DES_set_key_unchecked(&key3, &sch3);
1779 #endif
1780     AES_set_encrypt_key(key16, 128, &aes_ks1);
1781     AES_set_encrypt_key(key24, 192, &aes_ks2);
1782     AES_set_encrypt_key(key32, 256, &aes_ks3);
1783 #ifndef OPENSSL_NO_CAMELLIA
1784     Camellia_set_key(key16, 128, &camellia_ks1);
1785     Camellia_set_key(ckey24, 192, &camellia_ks2);
1786     Camellia_set_key(ckey32, 256, &camellia_ks3);
1787 #endif
1788 #ifndef OPENSSL_NO_IDEA
1789     IDEA_set_encrypt_key(key16, &idea_ks);
1790 #endif
1791 #ifndef OPENSSL_NO_SEED
1792     SEED_set_key(key16, &seed_ks);
1793 #endif
1794 #ifndef OPENSSL_NO_RC4
1795     RC4_set_key(&rc4_ks, 16, key16);
1796 #endif
1797 #ifndef OPENSSL_NO_RC2
1798     RC2_set_key(&rc2_ks, 16, key16, 128);
1799 #endif
1800 #ifndef OPENSSL_NO_RC5
1801     RC5_32_set_key(&rc5_ks, 16, key16, 12);
1802 #endif
1803 #ifndef OPENSSL_NO_BF
1804     BF_set_key(&bf_ks, 16, key16);
1805 #endif
1806 #ifndef OPENSSL_NO_CAST
1807     CAST_set_key(&cast_ks, 16, key16);
1808 #endif
1809 #ifndef SIGALRM
1810 # ifndef OPENSSL_NO_DES
1811     BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1812     count = 10;
1813     do {
1814         long it;
1815         count *= 2;
1816         Time_F(START);
1817         for (it = count; it; it--)
1818             DES_ecb_encrypt((DES_cblock *)loopargs[0].buf,
1819                             (DES_cblock *)loopargs[0].buf, &sch, DES_ENCRYPT);
1820         d = Time_F(STOP);
1821     } while (d < 3);
1822     save_count = count;
1823     c[D_MD2][0] = count / 10;
1824     c[D_MDC2][0] = count / 10;
1825     c[D_MD4][0] = count;
1826     c[D_MD5][0] = count;
1827     c[D_HMAC][0] = count;
1828     c[D_SHA1][0] = count;
1829     c[D_RMD160][0] = count;
1830     c[D_RC4][0] = count * 5;
1831     c[D_CBC_DES][0] = count;
1832     c[D_EDE3_DES][0] = count / 3;
1833     c[D_CBC_IDEA][0] = count;
1834     c[D_CBC_SEED][0] = count;
1835     c[D_CBC_RC2][0] = count;
1836     c[D_CBC_RC5][0] = count;
1837     c[D_CBC_BF][0] = count;
1838     c[D_CBC_CAST][0] = count;
1839     c[D_CBC_128_AES][0] = count;
1840     c[D_CBC_192_AES][0] = count;
1841     c[D_CBC_256_AES][0] = count;
1842     c[D_CBC_128_CML][0] = count;
1843     c[D_CBC_192_CML][0] = count;
1844     c[D_CBC_256_CML][0] = count;
1845     c[D_SHA256][0] = count;
1846     c[D_SHA512][0] = count;
1847     c[D_WHIRLPOOL][0] = count;
1848     c[D_IGE_128_AES][0] = count;
1849     c[D_IGE_192_AES][0] = count;
1850     c[D_IGE_256_AES][0] = count;
1851     c[D_GHASH][0] = count;
1852     c[D_RAND][0] = count;
1853
1854     for (i = 1; i < size_num; i++) {
1855         long l0, l1;
1856
1857         l0 = (long)lengths[0];
1858         l1 = (long)lengths[i];
1859
1860         c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1861         c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1862         c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1863         c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1864         c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1865         c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1866         c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1867         c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1868         c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1869         c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1870         c[D_GHASH][i] = c[D_GHASH][0] * 4 * l0 / l1;
1871         c[D_RAND][i] = c[D_RAND][0] * 4 * l0 / l1;
1872
1873         l0 = (long)lengths[i - 1];
1874
1875         c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1876         c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1877         c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1878         c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1879         c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1880         c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1881         c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1882         c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1883         c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1884         c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1885         c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1886         c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1887         c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1888         c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1889         c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1890         c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1891         c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1892         c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1893     }
1894
1895 #  ifndef OPENSSL_NO_RSA
1896     rsa_c[R_RSA_512][0] = count / 2000;
1897     rsa_c[R_RSA_512][1] = count / 400;
1898     for (i = 1; i < RSA_NUM; i++) {
1899         rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1900         rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1901         if (rsa_doit[i] <= 1 && rsa_c[i][0] == 0)
1902             rsa_doit[i] = 0;
1903         else {
1904             if (rsa_c[i][0] == 0) {
1905                 rsa_c[i][0] = 1; /* Set minimum iteration Nb to 1. */
1906                 rsa_c[i][1] = 20;
1907             }
1908         }
1909     }
1910 #  endif
1911
1912 #  ifndef OPENSSL_NO_DSA
1913     dsa_c[R_DSA_512][0] = count / 1000;
1914     dsa_c[R_DSA_512][1] = count / 1000 / 2;
1915     for (i = 1; i < DSA_NUM; i++) {
1916         dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1917         dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1918         if (dsa_doit[i] <= 1 && dsa_c[i][0] == 0)
1919             dsa_doit[i] = 0;
1920         else {
1921             if (dsa_c[i][0] == 0) {
1922                 dsa_c[i][0] = 1; /* Set minimum iteration Nb to 1. */
1923                 dsa_c[i][1] = 1;
1924             }
1925         }
1926     }
1927 #  endif
1928
1929 #  ifndef OPENSSL_NO_EC
1930     ecdsa_c[R_EC_P160][0] = count / 1000;
1931     ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1932     for (i = R_EC_P192; i <= R_EC_P521; i++) {
1933         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1934         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1935         if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1936             ecdsa_doit[i] = 0;
1937         else {
1938             if (ecdsa_c[i][0] == 0) {
1939                 ecdsa_c[i][0] = 1;
1940                 ecdsa_c[i][1] = 1;
1941             }
1942         }
1943     }
1944     ecdsa_c[R_EC_K163][0] = count / 1000;
1945     ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1946     for (i = R_EC_K233; i <= R_EC_K571; i++) {
1947         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1948         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1949         if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1950             ecdsa_doit[i] = 0;
1951         else {
1952             if (ecdsa_c[i][0] == 0) {
1953                 ecdsa_c[i][0] = 1;
1954                 ecdsa_c[i][1] = 1;
1955             }
1956         }
1957     }
1958     ecdsa_c[R_EC_B163][0] = count / 1000;
1959     ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1960     for (i = R_EC_B233; i <= R_EC_B571; i++) {
1961         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1962         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1963         if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1964             ecdsa_doit[i] = 0;
1965         else {
1966             if (ecdsa_c[i][0] == 0) {
1967                 ecdsa_c[i][0] = 1;
1968                 ecdsa_c[i][1] = 1;
1969             }
1970         }
1971     }
1972
1973     ecdh_c[R_EC_P160][0] = count / 1000;
1974     for (i = R_EC_P192; i <= R_EC_P521; i++) {
1975         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1976         if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1977             ecdh_doit[i] = 0;
1978         else {
1979             if (ecdh_c[i][0] == 0) {
1980                 ecdh_c[i][0] = 1;
1981             }
1982         }
1983     }
1984     ecdh_c[R_EC_K163][0] = count / 1000;
1985     for (i = R_EC_K233; i <= R_EC_K571; i++) {
1986         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1987         if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1988             ecdh_doit[i] = 0;
1989         else {
1990             if (ecdh_c[i][0] == 0) {
1991                 ecdh_c[i][0] = 1;
1992             }
1993         }
1994     }
1995     ecdh_c[R_EC_B163][0] = count / 1000;
1996     for (i = R_EC_B233; i <= R_EC_B571; i++) {
1997         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1998         if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1999             ecdh_doit[i] = 0;
2000         else {
2001             if (ecdh_c[i][0] == 0) {
2002                 ecdh_c[i][0] = 1;
2003             }
2004         }
2005     }
2006     /* repeated code good to factorize */
2007     ecdh_c[R_EC_BRP256R1][0] = count / 1000;
2008     for (i = R_EC_BRP384R1; i <= R_EC_BRP512R1; i += 2) {
2009         ecdh_c[i][0] = ecdh_c[i - 2][0] / 2;
2010         if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
2011             ecdh_doit[i] = 0;
2012         else {
2013             if (ecdh_c[i][0] == 0) {
2014                 ecdh_c[i][0] = 1;
2015             }
2016         }
2017     }
2018     ecdh_c[R_EC_BRP256T1][0] = count / 1000;
2019     for (i = R_EC_BRP384T1; i <= R_EC_BRP512T1; i += 2) {
2020         ecdh_c[i][0] = ecdh_c[i - 2][0] / 2;
2021         if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
2022             ecdh_doit[i] = 0;
2023         else {
2024             if (ecdh_c[i][0] == 0) {
2025                 ecdh_c[i][0] = 1;
2026             }
2027         }
2028     }
2029     /* default iteration count for the last two EC Curves */
2030     ecdh_c[R_EC_X25519][0] = count / 1800;
2031     ecdh_c[R_EC_X448][0] = count / 7200;
2032 #  endif
2033
2034 # else
2035 /* not worth fixing */
2036 #  error "You cannot disable DES on systems without SIGALRM."
2037 # endif                         /* OPENSSL_NO_DES */
2038 #elif SIGALRM > 0
2039     signal(SIGALRM, alarmed);
2040 #endif                          /* SIGALRM */
2041
2042 #ifndef OPENSSL_NO_MD2
2043     if (doit[D_MD2]) {
2044         for (testnum = 0; testnum < size_num; testnum++) {
2045             print_message(names[D_MD2], c[D_MD2][testnum], lengths[testnum],
2046                           seconds.sym);
2047             Time_F(START);
2048             count = run_benchmark(async_jobs, EVP_Digest_MD2_loop, loopargs);
2049             d = Time_F(STOP);
2050             print_result(D_MD2, testnum, count, d);
2051         }
2052     }
2053 #endif
2054 #ifndef OPENSSL_NO_MDC2
2055     if (doit[D_MDC2]) {
2056         for (testnum = 0; testnum < size_num; testnum++) {
2057             print_message(names[D_MDC2], c[D_MDC2][testnum], lengths[testnum],
2058                           seconds.sym);
2059             Time_F(START);
2060             count = run_benchmark(async_jobs, EVP_Digest_MDC2_loop, loopargs);
2061             d = Time_F(STOP);
2062             print_result(D_MDC2, testnum, count, d);
2063         }
2064     }
2065 #endif
2066
2067 #ifndef OPENSSL_NO_MD4
2068     if (doit[D_MD4]) {
2069         for (testnum = 0; testnum < size_num; testnum++) {
2070             print_message(names[D_MD4], c[D_MD4][testnum], lengths[testnum],
2071                           seconds.sym);
2072             Time_F(START);
2073             count = run_benchmark(async_jobs, EVP_Digest_MD4_loop, loopargs);
2074             d = Time_F(STOP);
2075             print_result(D_MD4, testnum, count, d);
2076         }
2077     }
2078 #endif
2079
2080 #ifndef OPENSSL_NO_MD5
2081     if (doit[D_MD5]) {
2082         for (testnum = 0; testnum < size_num; testnum++) {
2083             print_message(names[D_MD5], c[D_MD5][testnum], lengths[testnum],
2084                           seconds.sym);
2085             Time_F(START);
2086             count = run_benchmark(async_jobs, MD5_loop, loopargs);
2087             d = Time_F(STOP);
2088             print_result(D_MD5, testnum, count, d);
2089         }
2090     }
2091
2092     if (doit[D_HMAC]) {
2093         static const char hmac_key[] = "This is a key...";
2094         int len = strlen(hmac_key);
2095
2096         for (i = 0; i < loopargs_len; i++) {
2097             loopargs[i].hctx = HMAC_CTX_new();
2098             if (loopargs[i].hctx == NULL) {
2099                 BIO_printf(bio_err, "HMAC malloc failure, exiting...");
2100                 exit(1);
2101             }
2102
2103             HMAC_Init_ex(loopargs[i].hctx, hmac_key, len, EVP_md5(), NULL);
2104         }
2105         for (testnum = 0; testnum < size_num; testnum++) {
2106             print_message(names[D_HMAC], c[D_HMAC][testnum], lengths[testnum],
2107                           seconds.sym);
2108             Time_F(START);
2109             count = run_benchmark(async_jobs, HMAC_loop, loopargs);
2110             d = Time_F(STOP);
2111             print_result(D_HMAC, testnum, count, d);
2112         }
2113         for (i = 0; i < loopargs_len; i++) {
2114             HMAC_CTX_free(loopargs[i].hctx);
2115         }
2116     }
2117 #endif
2118     if (doit[D_SHA1]) {
2119         for (testnum = 0; testnum < size_num; testnum++) {
2120             print_message(names[D_SHA1], c[D_SHA1][testnum], lengths[testnum],
2121                           seconds.sym);
2122             Time_F(START);
2123             count = run_benchmark(async_jobs, SHA1_loop, loopargs);
2124             d = Time_F(STOP);
2125             print_result(D_SHA1, testnum, count, d);
2126         }
2127     }
2128     if (doit[D_SHA256]) {
2129         for (testnum = 0; testnum < size_num; testnum++) {
2130             print_message(names[D_SHA256], c[D_SHA256][testnum],
2131                           lengths[testnum], seconds.sym);
2132             Time_F(START);
2133             count = run_benchmark(async_jobs, SHA256_loop, loopargs);
2134             d = Time_F(STOP);
2135             print_result(D_SHA256, testnum, count, d);
2136         }
2137     }
2138     if (doit[D_SHA512]) {
2139         for (testnum = 0; testnum < size_num; testnum++) {
2140             print_message(names[D_SHA512], c[D_SHA512][testnum],
2141                           lengths[testnum], seconds.sym);
2142             Time_F(START);
2143             count = run_benchmark(async_jobs, SHA512_loop, loopargs);
2144             d = Time_F(STOP);
2145             print_result(D_SHA512, testnum, count, d);
2146         }
2147     }
2148 #ifndef OPENSSL_NO_WHIRLPOOL
2149     if (doit[D_WHIRLPOOL]) {
2150         for (testnum = 0; testnum < size_num; testnum++) {
2151             print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][testnum],
2152                           lengths[testnum], seconds.sym);
2153             Time_F(START);
2154             count = run_benchmark(async_jobs, WHIRLPOOL_loop, loopargs);
2155             d = Time_F(STOP);
2156             print_result(D_WHIRLPOOL, testnum, count, d);
2157         }
2158     }
2159 #endif
2160
2161 #ifndef OPENSSL_NO_RMD160
2162     if (doit[D_RMD160]) {
2163         for (testnum = 0; testnum < size_num; testnum++) {
2164             print_message(names[D_RMD160], c[D_RMD160][testnum],
2165                           lengths[testnum], seconds.sym);
2166             Time_F(START);
2167             count = run_benchmark(async_jobs, EVP_Digest_RMD160_loop, loopargs);
2168             d = Time_F(STOP);
2169             print_result(D_RMD160, testnum, count, d);
2170         }
2171     }
2172 #endif
2173 #ifndef OPENSSL_NO_RC4
2174     if (doit[D_RC4]) {
2175         for (testnum = 0; testnum < size_num; testnum++) {
2176             print_message(names[D_RC4], c[D_RC4][testnum], lengths[testnum],
2177                           seconds.sym);
2178             Time_F(START);
2179             count = run_benchmark(async_jobs, RC4_loop, loopargs);
2180             d = Time_F(STOP);
2181             print_result(D_RC4, testnum, count, d);
2182         }
2183     }
2184 #endif
2185 #ifndef OPENSSL_NO_DES
2186     if (doit[D_CBC_DES]) {
2187         for (testnum = 0; testnum < size_num; testnum++) {
2188             print_message(names[D_CBC_DES], c[D_CBC_DES][testnum],
2189                           lengths[testnum], seconds.sym);
2190             Time_F(START);
2191             count = run_benchmark(async_jobs, DES_ncbc_encrypt_loop, loopargs);
2192             d = Time_F(STOP);
2193             print_result(D_CBC_DES, testnum, count, d);
2194         }
2195     }
2196
2197     if (doit[D_EDE3_DES]) {
2198         for (testnum = 0; testnum < size_num; testnum++) {
2199             print_message(names[D_EDE3_DES], c[D_EDE3_DES][testnum],
2200                           lengths[testnum], seconds.sym);
2201             Time_F(START);
2202             count =
2203                 run_benchmark(async_jobs, DES_ede3_cbc_encrypt_loop, loopargs);
2204             d = Time_F(STOP);
2205             print_result(D_EDE3_DES, testnum, count, d);
2206         }
2207     }
2208 #endif
2209
2210     if (doit[D_CBC_128_AES]) {
2211         for (testnum = 0; testnum < size_num; testnum++) {
2212             print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][testnum],
2213                           lengths[testnum], seconds.sym);
2214             Time_F(START);
2215             count =
2216                 run_benchmark(async_jobs, AES_cbc_128_encrypt_loop, loopargs);
2217             d = Time_F(STOP);
2218             print_result(D_CBC_128_AES, testnum, count, d);
2219         }
2220     }
2221     if (doit[D_CBC_192_AES]) {
2222         for (testnum = 0; testnum < size_num; testnum++) {
2223             print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][testnum],
2224                           lengths[testnum], seconds.sym);
2225             Time_F(START);
2226             count =
2227                 run_benchmark(async_jobs, AES_cbc_192_encrypt_loop, loopargs);
2228             d = Time_F(STOP);
2229             print_result(D_CBC_192_AES, testnum, count, d);
2230         }
2231     }
2232     if (doit[D_CBC_256_AES]) {
2233         for (testnum = 0; testnum < size_num; testnum++) {
2234             print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][testnum],
2235                           lengths[testnum], seconds.sym);
2236             Time_F(START);
2237             count =
2238                 run_benchmark(async_jobs, AES_cbc_256_encrypt_loop, loopargs);
2239             d = Time_F(STOP);
2240             print_result(D_CBC_256_AES, testnum, count, d);
2241         }
2242     }
2243
2244     if (doit[D_IGE_128_AES]) {
2245         for (testnum = 0; testnum < size_num; testnum++) {
2246             print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][testnum],
2247                           lengths[testnum], seconds.sym);
2248             Time_F(START);
2249             count =
2250                 run_benchmark(async_jobs, AES_ige_128_encrypt_loop, loopargs);
2251             d = Time_F(STOP);
2252             print_result(D_IGE_128_AES, testnum, count, d);
2253         }
2254     }
2255     if (doit[D_IGE_192_AES]) {
2256         for (testnum = 0; testnum < size_num; testnum++) {
2257             print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][testnum],
2258                           lengths[testnum], seconds.sym);
2259             Time_F(START);
2260             count =
2261                 run_benchmark(async_jobs, AES_ige_192_encrypt_loop, loopargs);
2262             d = Time_F(STOP);
2263             print_result(D_IGE_192_AES, testnum, count, d);
2264         }
2265     }
2266     if (doit[D_IGE_256_AES]) {
2267         for (testnum = 0; testnum < size_num; testnum++) {
2268             print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][testnum],
2269                           lengths[testnum], seconds.sym);
2270             Time_F(START);
2271             count =
2272                 run_benchmark(async_jobs, AES_ige_256_encrypt_loop, loopargs);
2273             d = Time_F(STOP);
2274             print_result(D_IGE_256_AES, testnum, count, d);
2275         }
2276     }
2277     if (doit[D_GHASH]) {
2278         for (i = 0; i < loopargs_len; i++) {
2279             loopargs[i].gcm_ctx =
2280                 CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
2281             CRYPTO_gcm128_setiv(loopargs[i].gcm_ctx,
2282                                 (unsigned char *)"0123456789ab", 12);
2283         }
2284
2285         for (testnum = 0; testnum < size_num; testnum++) {
2286             print_message(names[D_GHASH], c[D_GHASH][testnum],
2287                           lengths[testnum], seconds.sym);
2288             Time_F(START);
2289             count = run_benchmark(async_jobs, CRYPTO_gcm128_aad_loop, loopargs);
2290             d = Time_F(STOP);
2291             print_result(D_GHASH, testnum, count, d);
2292         }
2293         for (i = 0; i < loopargs_len; i++)
2294             CRYPTO_gcm128_release(loopargs[i].gcm_ctx);
2295     }
2296 #ifndef OPENSSL_NO_CAMELLIA
2297     if (doit[D_CBC_128_CML]) {
2298         if (async_jobs > 0) {
2299             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2300                        names[D_CBC_128_CML]);
2301             doit[D_CBC_128_CML] = 0;
2302         }
2303         for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2304             print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][testnum],
2305                           lengths[testnum], seconds.sym);
2306             Time_F(START);
2307             for (count = 0, run = 1; COND(c[D_CBC_128_CML][testnum]); count++)
2308                 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2309                                      (size_t)lengths[testnum], &camellia_ks1,
2310                                      iv, CAMELLIA_ENCRYPT);
2311             d = Time_F(STOP);
2312             print_result(D_CBC_128_CML, testnum, count, d);
2313         }
2314     }
2315     if (doit[D_CBC_192_CML]) {
2316         if (async_jobs > 0) {
2317             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2318                        names[D_CBC_192_CML]);
2319             doit[D_CBC_192_CML] = 0;
2320         }
2321         for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2322             print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][testnum],
2323                           lengths[testnum], seconds.sym);
2324             if (async_jobs > 0) {
2325                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2326                 exit(1);
2327             }
2328             Time_F(START);
2329             for (count = 0, run = 1; COND(c[D_CBC_192_CML][testnum]); count++)
2330                 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2331                                      (size_t)lengths[testnum], &camellia_ks2,
2332                                      iv, CAMELLIA_ENCRYPT);
2333             d = Time_F(STOP);
2334             print_result(D_CBC_192_CML, testnum, count, d);
2335         }
2336     }
2337     if (doit[D_CBC_256_CML]) {
2338         if (async_jobs > 0) {
2339             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2340                        names[D_CBC_256_CML]);
2341             doit[D_CBC_256_CML] = 0;
2342         }
2343         for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2344             print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][testnum],
2345                           lengths[testnum], seconds.sym);
2346             Time_F(START);
2347             for (count = 0, run = 1; COND(c[D_CBC_256_CML][testnum]); count++)
2348                 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2349                                      (size_t)lengths[testnum], &camellia_ks3,
2350                                      iv, CAMELLIA_ENCRYPT);
2351             d = Time_F(STOP);
2352             print_result(D_CBC_256_CML, testnum, count, d);
2353         }
2354     }
2355 #endif
2356 #ifndef OPENSSL_NO_IDEA
2357     if (doit[D_CBC_IDEA]) {
2358         if (async_jobs > 0) {
2359             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2360                        names[D_CBC_IDEA]);
2361             doit[D_CBC_IDEA] = 0;
2362         }
2363         for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2364             print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][testnum],
2365                           lengths[testnum], seconds.sym);
2366             Time_F(START);
2367             for (count = 0, run = 1; COND(c[D_CBC_IDEA][testnum]); count++)
2368                 IDEA_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2369                                  (size_t)lengths[testnum], &idea_ks,
2370                                  iv, IDEA_ENCRYPT);
2371             d = Time_F(STOP);
2372             print_result(D_CBC_IDEA, testnum, count, d);
2373         }
2374     }
2375 #endif
2376 #ifndef OPENSSL_NO_SEED
2377     if (doit[D_CBC_SEED]) {
2378         if (async_jobs > 0) {
2379             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2380                        names[D_CBC_SEED]);
2381             doit[D_CBC_SEED] = 0;
2382         }
2383         for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2384             print_message(names[D_CBC_SEED], c[D_CBC_SEED][testnum],
2385                           lengths[testnum], seconds.sym);
2386             Time_F(START);
2387             for (count = 0, run = 1; COND(c[D_CBC_SEED][testnum]); count++)
2388                 SEED_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2389                                  (size_t)lengths[testnum], &seed_ks, iv, 1);
2390             d = Time_F(STOP);
2391             print_result(D_CBC_SEED, testnum, count, d);
2392         }
2393     }
2394 #endif
2395 #ifndef OPENSSL_NO_RC2
2396     if (doit[D_CBC_RC2]) {
2397         if (async_jobs > 0) {
2398             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2399                        names[D_CBC_RC2]);
2400             doit[D_CBC_RC2] = 0;
2401         }
2402         for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2403             print_message(names[D_CBC_RC2], c[D_CBC_RC2][testnum],
2404                           lengths[testnum], seconds.sym);
2405             if (async_jobs > 0) {
2406                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2407                 exit(1);
2408             }
2409             Time_F(START);
2410             for (count = 0, run = 1; COND(c[D_CBC_RC2][testnum]); count++)
2411                 RC2_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2412                                 (size_t)lengths[testnum], &rc2_ks,
2413                                 iv, RC2_ENCRYPT);
2414             d = Time_F(STOP);
2415             print_result(D_CBC_RC2, testnum, count, d);
2416         }
2417     }
2418 #endif
2419 #ifndef OPENSSL_NO_RC5
2420     if (doit[D_CBC_RC5]) {
2421         if (async_jobs > 0) {
2422             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2423                        names[D_CBC_RC5]);
2424             doit[D_CBC_RC5] = 0;
2425         }
2426         for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2427             print_message(names[D_CBC_RC5], c[D_CBC_RC5][testnum],
2428                           lengths[testnum], seconds.sym);
2429             if (async_jobs > 0) {
2430                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2431                 exit(1);
2432             }
2433             Time_F(START);
2434             for (count = 0, run = 1; COND(c[D_CBC_RC5][testnum]); count++)
2435                 RC5_32_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2436                                    (size_t)lengths[testnum], &rc5_ks,
2437                                    iv, RC5_ENCRYPT);
2438             d = Time_F(STOP);
2439             print_result(D_CBC_RC5, testnum, count, d);
2440         }
2441     }
2442 #endif
2443 #ifndef OPENSSL_NO_BF
2444     if (doit[D_CBC_BF]) {
2445         if (async_jobs > 0) {
2446             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2447                        names[D_CBC_BF]);
2448             doit[D_CBC_BF] = 0;
2449         }
2450         for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2451             print_message(names[D_CBC_BF], c[D_CBC_BF][testnum],
2452                           lengths[testnum], seconds.sym);
2453             Time_F(START);
2454             for (count = 0, run = 1; COND(c[D_CBC_BF][testnum]); count++)
2455                 BF_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2456                                (size_t)lengths[testnum], &bf_ks,
2457                                iv, BF_ENCRYPT);
2458             d = Time_F(STOP);
2459             print_result(D_CBC_BF, testnum, count, d);
2460         }
2461     }
2462 #endif
2463 #ifndef OPENSSL_NO_CAST
2464     if (doit[D_CBC_CAST]) {
2465         if (async_jobs > 0) {
2466             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2467                        names[D_CBC_CAST]);
2468             doit[D_CBC_CAST] = 0;
2469         }
2470         for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2471             print_message(names[D_CBC_CAST], c[D_CBC_CAST][testnum],
2472                           lengths[testnum], seconds.sym);
2473             Time_F(START);
2474             for (count = 0, run = 1; COND(c[D_CBC_CAST][testnum]); count++)
2475                 CAST_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2476                                  (size_t)lengths[testnum], &cast_ks,
2477                                  iv, CAST_ENCRYPT);
2478             d = Time_F(STOP);
2479             print_result(D_CBC_CAST, testnum, count, d);
2480         }
2481     }
2482 #endif
2483     if (doit[D_RAND]) {
2484         for (testnum = 0; testnum < size_num; testnum++) {
2485             print_message(names[D_RAND], c[D_RAND][testnum], lengths[testnum],
2486                           seconds.sym);
2487             Time_F(START);
2488             count = run_benchmark(async_jobs, RAND_bytes_loop, loopargs);
2489             d = Time_F(STOP);
2490             print_result(D_RAND, testnum, count, d);
2491         }
2492     }
2493
2494     if (doit[D_EVP]) {
2495         if (evp_cipher != NULL) {
2496             int (*loopfunc)(void *args) = EVP_Update_loop;
2497
2498             if (multiblock && (EVP_CIPHER_flags(evp_cipher) &
2499                                EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
2500                 multiblock_speed(evp_cipher, lengths_single, &seconds);
2501                 ret = 0;
2502                 goto end;
2503             }
2504
2505             names[D_EVP] = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
2506
2507             if (EVP_CIPHER_mode(evp_cipher) == EVP_CIPH_CCM_MODE) {
2508                 loopfunc = EVP_Update_loop_ccm;
2509             } else if (aead && (EVP_CIPHER_flags(evp_cipher) &
2510                                 EVP_CIPH_FLAG_AEAD_CIPHER)) {
2511                 loopfunc = EVP_Update_loop_aead;
2512                 if (lengths == lengths_list) {
2513                     lengths = aead_lengths_list;
2514                     size_num = OSSL_NELEM(aead_lengths_list);
2515                 }
2516             }
2517
2518             for (testnum = 0; testnum < size_num; testnum++) {
2519                 print_message(names[D_EVP], save_count, lengths[testnum],
2520                               seconds.sym);
2521
2522                 for (k = 0; k < loopargs_len; k++) {
2523                     loopargs[k].ctx = EVP_CIPHER_CTX_new();
2524                     EVP_CipherInit_ex(loopargs[k].ctx, evp_cipher, NULL, NULL,
2525                                       iv, decrypt ? 0 : 1);
2526
2527                     EVP_CIPHER_CTX_set_padding(loopargs[k].ctx, 0);
2528
2529                     keylen = EVP_CIPHER_CTX_key_length(loopargs[k].ctx);
2530                     loopargs[k].key = app_malloc(keylen, "evp_cipher key");
2531                     EVP_CIPHER_CTX_rand_key(loopargs[k].ctx, loopargs[k].key);
2532                     EVP_CipherInit_ex(loopargs[k].ctx, NULL, NULL,
2533                                       loopargs[k].key, NULL, -1);
2534                     OPENSSL_clear_free(loopargs[k].key, keylen);
2535                 }
2536
2537                 Time_F(START);
2538                 count = run_benchmark(async_jobs, loopfunc, loopargs);
2539                 d = Time_F(STOP);
2540                 for (k = 0; k < loopargs_len; k++) {
2541                     EVP_CIPHER_CTX_free(loopargs[k].ctx);
2542                 }
2543                 print_result(D_EVP, testnum, count, d);
2544             }
2545         } else if (evp_md != NULL) {
2546             names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
2547
2548             for (testnum = 0; testnum < size_num; testnum++) {
2549                 print_message(names[D_EVP], save_count, lengths[testnum],
2550                               seconds.sym);
2551                 Time_F(START);
2552                 count = run_benchmark(async_jobs, EVP_Digest_loop, loopargs);
2553                 d = Time_F(STOP);
2554                 print_result(D_EVP, testnum, count, d);
2555             }
2556         }
2557     }
2558
2559     for (i = 0; i < loopargs_len; i++)
2560         RAND_bytes(loopargs[i].buf, 36);
2561
2562 #ifndef OPENSSL_NO_RSA
2563     for (testnum = 0; testnum < RSA_NUM; testnum++) {
2564         int st = 0;
2565         if (!rsa_doit[testnum])
2566             continue;
2567         for (i = 0; i < loopargs_len; i++) {
2568             if (primes > 2) {
2569                 /* we haven't set keys yet,  generate multi-prime RSA keys */
2570                 BIGNUM *bn = BN_new();
2571
2572                 if (bn == NULL)
2573                     goto end;
2574                 if (!BN_set_word(bn, RSA_F4)) {
2575                     BN_free(bn);
2576                     goto end;
2577                 }
2578
2579                 BIO_printf(bio_err, "Generate multi-prime RSA key for %s\n",
2580                            rsa_choices[testnum].name);
2581
2582                 loopargs[i].rsa_key[testnum] = RSA_new();
2583                 if (loopargs[i].rsa_key[testnum] == NULL) {
2584                     BN_free(bn);
2585                     goto end;
2586                 }
2587
2588                 if (!RSA_generate_multi_prime_key(loopargs[i].rsa_key[testnum],
2589                                                   rsa_bits[testnum],
2590                                                   primes, bn, NULL)) {
2591                     BN_free(bn);
2592                     goto end;
2593                 }
2594                 BN_free(bn);
2595             }
2596             st = RSA_sign(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2597                           &loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2598             if (st == 0)
2599                 break;
2600         }
2601         if (st == 0) {
2602             BIO_printf(bio_err,
2603                        "RSA sign failure.  No RSA sign will be done.\n");
2604             ERR_print_errors(bio_err);
2605             rsa_count = 1;
2606         } else {
2607             pkey_print_message("private", "rsa",
2608                                rsa_c[testnum][0], rsa_bits[testnum],
2609                                seconds.rsa);
2610             /* RSA_blinding_on(rsa_key[testnum],NULL); */
2611             Time_F(START);
2612             count = run_benchmark(async_jobs, RSA_sign_loop, loopargs);
2613             d = Time_F(STOP);
2614             BIO_printf(bio_err,
2615                        mr ? "+R1:%ld:%d:%.2f\n"
2616                        : "%ld %u bits private RSA's in %.2fs\n",
2617                        count, rsa_bits[testnum], d);
2618             rsa_results[testnum][0] = (double)count / d;
2619             rsa_count = count;
2620         }
2621
2622         for (i = 0; i < loopargs_len; i++) {
2623             st = RSA_verify(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2624                             loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2625             if (st <= 0)
2626                 break;
2627         }
2628         if (st <= 0) {
2629             BIO_printf(bio_err,
2630                        "RSA verify failure.  No RSA verify will be done.\n");
2631             ERR_print_errors(bio_err);
2632             rsa_doit[testnum] = 0;
2633         } else {
2634             pkey_print_message("public", "rsa",
2635                                rsa_c[testnum][1], rsa_bits[testnum],
2636                                seconds.rsa);
2637             Time_F(START);
2638             count = run_benchmark(async_jobs, RSA_verify_loop, loopargs);
2639             d = Time_F(STOP);
2640             BIO_printf(bio_err,
2641                        mr ? "+R2:%ld:%d:%.2f\n"
2642                        : "%ld %u bits public RSA's in %.2fs\n",
2643                        count, rsa_bits[testnum], d);
2644             rsa_results[testnum][1] = (double)count / d;
2645         }
2646
2647         if (rsa_count <= 1) {
2648             /* if longer than 10s, don't do any more */
2649             for (testnum++; testnum < RSA_NUM; testnum++)
2650                 rsa_doit[testnum] = 0;
2651         }
2652     }
2653 #endif                          /* OPENSSL_NO_RSA */
2654
2655     for (i = 0; i < loopargs_len; i++)
2656         RAND_bytes(loopargs[i].buf, 36);
2657
2658 #ifndef OPENSSL_NO_DSA
2659     for (testnum = 0; testnum < DSA_NUM; testnum++) {
2660         int st = 0;
2661         if (!dsa_doit[testnum])
2662             continue;
2663
2664         /* DSA_generate_key(dsa_key[testnum]); */
2665         /* DSA_sign_setup(dsa_key[testnum],NULL); */
2666         for (i = 0; i < loopargs_len; i++) {
2667             st = DSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2668                           &loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2669             if (st == 0)
2670                 break;
2671         }
2672         if (st == 0) {
2673             BIO_printf(bio_err,
2674                        "DSA sign failure.  No DSA sign will be done.\n");
2675             ERR_print_errors(bio_err);
2676             rsa_count = 1;
2677         } else {
2678             pkey_print_message("sign", "dsa",
2679                                dsa_c[testnum][0], dsa_bits[testnum],
2680                                seconds.dsa);
2681             Time_F(START);
2682             count = run_benchmark(async_jobs, DSA_sign_loop, loopargs);
2683             d = Time_F(STOP);
2684             BIO_printf(bio_err,
2685                        mr ? "+R3:%ld:%u:%.2f\n"
2686                        : "%ld %u bits DSA signs in %.2fs\n",
2687                        count, dsa_bits[testnum], d);
2688             dsa_results[testnum][0] = (double)count / d;
2689             rsa_count = count;
2690         }
2691
2692         for (i = 0; i < loopargs_len; i++) {
2693             st = DSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2694                             loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2695             if (st <= 0)
2696                 break;
2697         }
2698         if (st <= 0) {
2699             BIO_printf(bio_err,
2700                        "DSA verify failure.  No DSA verify will be done.\n");
2701             ERR_print_errors(bio_err);
2702             dsa_doit[testnum] = 0;
2703         } else {
2704             pkey_print_message("verify", "dsa",
2705                                dsa_c[testnum][1], dsa_bits[testnum],
2706                                seconds.dsa);
2707             Time_F(START);
2708             count = run_benchmark(async_jobs, DSA_verify_loop, loopargs);
2709             d = Time_F(STOP);
2710             BIO_printf(bio_err,
2711                        mr ? "+R4:%ld:%u:%.2f\n"
2712                        : "%ld %u bits DSA verify in %.2fs\n",
2713                        count, dsa_bits[testnum], d);
2714             dsa_results[testnum][1] = (double)count / d;
2715         }
2716
2717         if (rsa_count <= 1) {
2718             /* if longer than 10s, don't do any more */
2719             for (testnum++; testnum < DSA_NUM; testnum++)
2720                 dsa_doit[testnum] = 0;
2721         }
2722     }
2723 #endif                          /* OPENSSL_NO_DSA */
2724
2725 #ifndef OPENSSL_NO_EC
2726     for (testnum = 0; testnum < ECDSA_NUM; testnum++) {
2727         int st = 1;
2728
2729         if (!ecdsa_doit[testnum])
2730             continue;           /* Ignore Curve */
2731         for (i = 0; i < loopargs_len; i++) {
2732             loopargs[i].ecdsa[testnum] =
2733                 EC_KEY_new_by_curve_name(test_curves[testnum].nid);
2734             if (loopargs[i].ecdsa[testnum] == NULL) {
2735                 st = 0;
2736                 break;
2737             }
2738         }
2739         if (st == 0) {
2740             BIO_printf(bio_err, "ECDSA failure.\n");
2741             ERR_print_errors(bio_err);
2742             rsa_count = 1;
2743         } else {
2744             for (i = 0; i < loopargs_len; i++) {
2745                 EC_KEY_precompute_mult(loopargs[i].ecdsa[testnum], NULL);
2746                 /* Perform ECDSA signature test */
2747                 EC_KEY_generate_key(loopargs[i].ecdsa[testnum]);
2748                 st = ECDSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2749                                 &loopargs[i].siglen,
2750                                 loopargs[i].ecdsa[testnum]);
2751                 if (st == 0)
2752                     break;
2753             }
2754             if (st == 0) {
2755                 BIO_printf(bio_err,
2756                            "ECDSA sign failure.  No ECDSA sign will be done.\n");
2757                 ERR_print_errors(bio_err);
2758                 rsa_count = 1;
2759             } else {
2760                 pkey_print_message("sign", "ecdsa",
2761                                    ecdsa_c[testnum][0],
2762                                    test_curves[testnum].bits, seconds.ecdsa);
2763                 Time_F(START);
2764                 count = run_benchmark(async_jobs, ECDSA_sign_loop, loopargs);
2765                 d = Time_F(STOP);
2766
2767                 BIO_printf(bio_err,
2768                            mr ? "+R5:%ld:%u:%.2f\n" :
2769                            "%ld %u bits ECDSA signs in %.2fs \n",
2770                            count, test_curves[testnum].bits, d);
2771                 ecdsa_results[testnum][0] = (double)count / d;
2772                 rsa_count = count;
2773             }
2774
2775             /* Perform ECDSA verification test */
2776             for (i = 0; i < loopargs_len; i++) {
2777                 st = ECDSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2778                                   loopargs[i].siglen,
2779                                   loopargs[i].ecdsa[testnum]);
2780                 if (st != 1)
2781                     break;
2782             }
2783             if (st != 1) {
2784                 BIO_printf(bio_err,
2785                            "ECDSA verify failure.  No ECDSA verify will be done.\n");
2786                 ERR_print_errors(bio_err);
2787                 ecdsa_doit[testnum] = 0;
2788             } else {
2789                 pkey_print_message("verify", "ecdsa",
2790                                    ecdsa_c[testnum][1],
2791                                    test_curves[testnum].bits, seconds.ecdsa);
2792                 Time_F(START);
2793                 count = run_benchmark(async_jobs, ECDSA_verify_loop, loopargs);
2794                 d = Time_F(STOP);
2795                 BIO_printf(bio_err,
2796                            mr ? "+R6:%ld:%u:%.2f\n"
2797                            : "%ld %u bits ECDSA verify in %.2fs\n",
2798                            count, test_curves[testnum].bits, d);
2799                 ecdsa_results[testnum][1] = (double)count / d;
2800             }
2801
2802             if (rsa_count <= 1) {
2803                 /* if longer than 10s, don't do any more */
2804                 for (testnum++; testnum < EC_NUM; testnum++)
2805                     ecdsa_doit[testnum] = 0;
2806             }
2807         }
2808     }
2809
2810     for (testnum = 0; testnum < EC_NUM; testnum++) {
2811         int ecdh_checks = 1;
2812
2813         if (!ecdh_doit[testnum])
2814             continue;
2815
2816         for (i = 0; i < loopargs_len; i++) {
2817             EVP_PKEY_CTX *kctx = NULL;
2818             EVP_PKEY_CTX *test_ctx = NULL;
2819             EVP_PKEY_CTX *ctx = NULL;
2820             EVP_PKEY *key_A = NULL;
2821             EVP_PKEY *key_B = NULL;
2822             size_t outlen;
2823             size_t test_outlen;
2824
2825             /* Ensure that the error queue is empty */
2826             if (ERR_peek_error()) {
2827                 BIO_printf(bio_err,
2828                            "WARNING: the error queue contains previous unhandled errors.\n");
2829                 ERR_print_errors(bio_err);
2830             }
2831
2832             /* Let's try to create a ctx directly from the NID: this works for
2833              * curves like Curve25519 that are not implemented through the low
2834              * level EC interface.
2835              * If this fails we try creating a EVP_PKEY_EC generic param ctx,
2836              * then we set the curve by NID before deriving the actual keygen
2837              * ctx for that specific curve. */
2838             kctx = EVP_PKEY_CTX_new_id(test_curves[testnum].nid, NULL); /* keygen ctx from NID */
2839             if (!kctx) {
2840                 EVP_PKEY_CTX *pctx = NULL;
2841                 EVP_PKEY *params = NULL;
2842
2843                 /* If we reach this code EVP_PKEY_CTX_new_id() failed and a
2844                  * "int_ctx_new:unsupported algorithm" error was added to the
2845                  * error queue.
2846                  * We remove it from the error queue as we are handling it. */
2847                 unsigned long error = ERR_peek_error(); /* peek the latest error in the queue */
2848                 if (error == ERR_peek_last_error() && /* oldest and latest errors match */
2849                     /* check that the error origin matches */
2850                     ERR_GET_LIB(error) == ERR_LIB_EVP &&
2851                     ERR_GET_FUNC(error) == EVP_F_INT_CTX_NEW &&
2852                     ERR_GET_REASON(error) == EVP_R_UNSUPPORTED_ALGORITHM)
2853                     ERR_get_error(); /* pop error from queue */
2854                 if (ERR_peek_error()) {
2855                     BIO_printf(bio_err,
2856                                "Unhandled error in the error queue during ECDH init.\n");
2857                     ERR_print_errors(bio_err);
2858                     rsa_count = 1;
2859                     break;
2860                 }
2861
2862                 if (            /* Create the context for parameter generation */
2863                        !(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL)) ||
2864                        /* Initialise the parameter generation */
2865                        !EVP_PKEY_paramgen_init(pctx) ||
2866                        /* Set the curve by NID */
2867                        !EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx,
2868                                                                test_curves
2869                                                                [testnum].nid) ||
2870                        /* Create the parameter object params */
2871                        !EVP_PKEY_paramgen(pctx, &params)) {
2872                     ecdh_checks = 0;
2873                     BIO_printf(bio_err, "ECDH EC params init failure.\n");
2874                     ERR_print_errors(bio_err);
2875                     rsa_count = 1;
2876                     break;
2877                 }
2878                 /* Create the context for the key generation */
2879                 kctx = EVP_PKEY_CTX_new(params, NULL);
2880
2881                 EVP_PKEY_free(params);
2882                 params = NULL;
2883                 EVP_PKEY_CTX_free(pctx);
2884                 pctx = NULL;
2885             }
2886             if (kctx == NULL ||      /* keygen ctx is not null */
2887                 !EVP_PKEY_keygen_init(kctx) /* init keygen ctx */ ) {
2888                 ecdh_checks = 0;
2889                 BIO_printf(bio_err, "ECDH keygen failure.\n");
2890                 ERR_print_errors(bio_err);
2891                 rsa_count = 1;
2892                 break;
2893             }
2894
2895             if (!EVP_PKEY_keygen(kctx, &key_A) || /* generate secret key A */
2896                 !EVP_PKEY_keygen(kctx, &key_B) || /* generate secret key B */
2897                 !(ctx = EVP_PKEY_CTX_new(key_A, NULL)) || /* derivation ctx from skeyA */
2898                 !EVP_PKEY_derive_init(ctx) || /* init derivation ctx */
2899                 !EVP_PKEY_derive_set_peer(ctx, key_B) || /* set peer pubkey in ctx */
2900                 !EVP_PKEY_derive(ctx, NULL, &outlen) || /* determine max length */
2901                 outlen == 0 ||  /* ensure outlen is a valid size */
2902                 outlen > MAX_ECDH_SIZE /* avoid buffer overflow */ ) {
2903                 ecdh_checks = 0;
2904                 BIO_printf(bio_err, "ECDH key generation failure.\n");
2905                 ERR_print_errors(bio_err);
2906                 rsa_count = 1;
2907                 break;
2908             }
2909
2910             /* Here we perform a test run, comparing the output of a*B and b*A;
2911              * we try this here and assume that further EVP_PKEY_derive calls
2912              * never fail, so we can skip checks in the actually benchmarked
2913              * code, for maximum performance. */
2914             if (!(test_ctx = EVP_PKEY_CTX_new(key_B, NULL)) || /* test ctx from skeyB */
2915                 !EVP_PKEY_derive_init(test_ctx) || /* init derivation test_ctx */
2916                 !EVP_PKEY_derive_set_peer(test_ctx, key_A) || /* set peer pubkey in test_ctx */
2917                 !EVP_PKEY_derive(test_ctx, NULL, &test_outlen) || /* determine max length */
2918                 !EVP_PKEY_derive(ctx, loopargs[i].secret_a, &outlen) || /* compute a*B */
2919                 !EVP_PKEY_derive(test_ctx, loopargs[i].secret_b, &test_outlen) || /* compute b*A */
2920                 test_outlen != outlen /* compare output length */ ) {
2921                 ecdh_checks = 0;
2922                 BIO_printf(bio_err, "ECDH computation failure.\n");
2923                 ERR_print_errors(bio_err);
2924                 rsa_count = 1;
2925                 break;
2926             }
2927
2928             /* Compare the computation results: CRYPTO_memcmp() returns 0 if equal */
2929             if (CRYPTO_memcmp(loopargs[i].secret_a,
2930                               loopargs[i].secret_b, outlen)) {
2931                 ecdh_checks = 0;
2932                 BIO_printf(bio_err, "ECDH computations don't match.\n");
2933                 ERR_print_errors(bio_err);
2934                 rsa_count = 1;
2935                 break;
2936             }
2937
2938             loopargs[i].ecdh_ctx[testnum] = ctx;
2939             loopargs[i].outlen[testnum] = outlen;
2940
2941             EVP_PKEY_free(key_A);
2942             EVP_PKEY_free(key_B);
2943             EVP_PKEY_CTX_free(kctx);
2944             kctx = NULL;
2945             EVP_PKEY_CTX_free(test_ctx);
2946             test_ctx = NULL;
2947         }
2948         if (ecdh_checks != 0) {
2949             pkey_print_message("", "ecdh",
2950                                ecdh_c[testnum][0],
2951                                test_curves[testnum].bits, seconds.ecdh);
2952             Time_F(START);
2953             count =
2954                 run_benchmark(async_jobs, ECDH_EVP_derive_key_loop, loopargs);
2955             d = Time_F(STOP);
2956             BIO_printf(bio_err,
2957                        mr ? "+R7:%ld:%d:%.2f\n" :
2958                        "%ld %u-bits ECDH ops in %.2fs\n", count,
2959                        test_curves[testnum].bits, d);
2960             ecdh_results[testnum][0] = (double)count / d;
2961             rsa_count = count;
2962         }
2963
2964         if (rsa_count <= 1) {
2965             /* if longer than 10s, don't do any more */
2966             for (testnum++; testnum < OSSL_NELEM(ecdh_doit); testnum++)
2967                 ecdh_doit[testnum] = 0;
2968         }
2969     }
2970 #endif                          /* OPENSSL_NO_EC */
2971 #ifndef NO_FORK
2972  show_res:
2973 #endif
2974     if (!mr) {
2975         printf("%s\n", OpenSSL_version(OPENSSL_VERSION));
2976         printf("%s\n", OpenSSL_version(OPENSSL_BUILT_ON));
2977         printf("options:");
2978         printf("%s ", BN_options());
2979 #ifndef OPENSSL_NO_MD2
2980         printf("%s ", MD2_options());
2981 #endif
2982 #ifndef OPENSSL_NO_RC4
2983         printf("%s ", RC4_options());
2984 #endif
2985 #ifndef OPENSSL_NO_DES
2986         printf("%s ", DES_options());
2987 #endif
2988         printf("%s ", AES_options());
2989 #ifndef OPENSSL_NO_IDEA
2990         printf("%s ", IDEA_options());
2991 #endif
2992 #ifndef OPENSSL_NO_BF
2993         printf("%s ", BF_options());
2994 #endif
2995         printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
2996     }
2997
2998     if (pr_header) {
2999         if (mr)
3000             printf("+H");
3001         else {
3002             printf
3003                 ("The 'numbers' are in 1000s of bytes per second processed.\n");
3004             printf("type        ");
3005         }
3006         for (testnum = 0; testnum < size_num; testnum++)
3007             printf(mr ? ":%d" : "%7d bytes", lengths[testnum]);
3008         printf("\n");
3009     }
3010
3011     for (k = 0; k < ALGOR_NUM; k++) {
3012         if (!doit[k])
3013             continue;
3014         if (mr)
3015             printf("+F:%u:%s", k, names[k]);
3016         else
3017             printf("%-13s", names[k]);
3018         for (testnum = 0; testnum < size_num; testnum++) {
3019             if (results[k][testnum] > 10000 && !mr)
3020                 printf(" %11.2fk", results[k][testnum] / 1e3);
3021             else
3022                 printf(mr ? ":%.2f" : " %11.2f ", results[k][testnum]);
3023         }
3024         printf("\n");
3025     }
3026 #ifndef OPENSSL_NO_RSA
3027     testnum = 1;
3028     for (k = 0; k < RSA_NUM; k++) {
3029         if (!rsa_doit[k])
3030             continue;
3031         if (testnum && !mr) {
3032             printf("%18ssign    verify    sign/s verify/s\n", " ");
3033             testnum = 0;
3034         }
3035         if (mr)
3036             printf("+F2:%u:%u:%f:%f\n",
3037                    k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
3038         else
3039             printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
3040                    rsa_bits[k], 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1],
3041                    rsa_results[k][0], rsa_results[k][1]);
3042     }
3043 #endif
3044 #ifndef OPENSSL_NO_DSA
3045     testnum = 1;
3046     for (k = 0; k < DSA_NUM; k++) {
3047         if (!dsa_doit[k])
3048             continue;
3049         if (testnum && !mr) {
3050             printf("%18ssign    verify    sign/s verify/s\n", " ");
3051             testnum = 0;
3052         }
3053         if (mr)
3054             printf("+F3:%u:%u:%f:%f\n",
3055                    k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
3056         else
3057             printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
3058                    dsa_bits[k], 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1],
3059                    dsa_results[k][0], dsa_results[k][1]);
3060     }
3061 #endif
3062 #ifndef OPENSSL_NO_EC
3063     testnum = 1;
3064     for (k = 0; k < OSSL_NELEM(ecdsa_doit); k++) {
3065         if (!ecdsa_doit[k])
3066             continue;
3067         if (testnum && !mr) {
3068             printf("%30ssign    verify    sign/s verify/s\n", " ");
3069             testnum = 0;
3070         }
3071
3072         if (mr)
3073             printf("+F4:%u:%u:%f:%f\n",
3074                    k, test_curves[k].bits,
3075                    ecdsa_results[k][0], ecdsa_results[k][1]);
3076         else
3077             printf("%4u bits ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
3078                    test_curves[k].bits, test_curves[k].name,
3079                    1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1],
3080                    ecdsa_results[k][0], ecdsa_results[k][1]);
3081     }
3082
3083     testnum = 1;
3084     for (k = 0; k < EC_NUM; k++) {
3085         if (!ecdh_doit[k])
3086             continue;
3087         if (testnum && !mr) {
3088             printf("%30sop      op/s\n", " ");
3089             testnum = 0;
3090         }
3091         if (mr)
3092             printf("+F5:%u:%u:%f:%f\n",
3093                    k, test_curves[k].bits,
3094                    ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
3095
3096         else
3097             printf("%4u bits ecdh (%s) %8.4fs %8.1f\n",
3098                    test_curves[k].bits, test_curves[k].name,
3099                    1.0 / ecdh_results[k][0], ecdh_results[k][0]);
3100     }
3101 #endif
3102
3103     ret = 0;
3104
3105  end:
3106     ERR_print_errors(bio_err);
3107     for (i = 0; i < loopargs_len; i++) {
3108         OPENSSL_free(loopargs[i].buf_malloc);
3109         OPENSSL_free(loopargs[i].buf2_malloc);
3110
3111 #ifndef OPENSSL_NO_RSA
3112         for (k = 0; k < RSA_NUM; k++)
3113             RSA_free(loopargs[i].rsa_key[k]);
3114 #endif
3115 #ifndef OPENSSL_NO_DSA
3116         for (k = 0; k < DSA_NUM; k++)
3117             DSA_free(loopargs[i].dsa_key[k]);
3118 #endif
3119 #ifndef OPENSSL_NO_EC
3120         for (k = 0; k < ECDSA_NUM; k++)
3121             EC_KEY_free(loopargs[i].ecdsa[k]);
3122         for (k = 0; k < EC_NUM; k++)
3123             EVP_PKEY_CTX_free(loopargs[i].ecdh_ctx[k]);
3124         OPENSSL_free(loopargs[i].secret_a);
3125         OPENSSL_free(loopargs[i].secret_b);
3126 #endif
3127     }
3128
3129     if (async_jobs > 0) {
3130         for (i = 0; i < loopargs_len; i++)
3131             ASYNC_WAIT_CTX_free(loopargs[i].wait_ctx);
3132     }
3133
3134     if (async_init) {
3135         ASYNC_cleanup_thread();
3136     }
3137     OPENSSL_free(loopargs);
3138     release_engine(e);
3139     return ret;
3140 }
3141
3142 static void print_message(const char *s, long num, int length, int tm)
3143 {
3144 #ifdef SIGALRM
3145     BIO_printf(bio_err,
3146                mr ? "+DT:%s:%d:%d\n"
3147                : "Doing %s for %ds on %d size blocks: ", s, tm, length);
3148     (void)BIO_flush(bio_err);
3149     alarm(tm);
3150 #else
3151     BIO_printf(bio_err,
3152                mr ? "+DN:%s:%ld:%d\n"
3153                : "Doing %s %ld times on %d size blocks: ", s, num, length);
3154     (void)BIO_flush(bio_err);
3155 #endif
3156 }
3157
3158 static void pkey_print_message(const char *str, const char *str2, long num,
3159                                unsigned int bits, int tm)
3160 {
3161 #ifdef SIGALRM
3162     BIO_printf(bio_err,
3163                mr ? "+DTP:%d:%s:%s:%d\n"
3164                : "Doing %u bits %s %s's for %ds: ", bits, str, str2, tm);
3165     (void)BIO_flush(bio_err);
3166     alarm(tm);
3167 #else
3168     BIO_printf(bio_err,
3169                mr ? "+DNP:%ld:%d:%s:%s\n"
3170                : "Doing %ld %u bits %s %s's: ", num, bits, str, str2);
3171     (void)BIO_flush(bio_err);
3172 #endif
3173 }
3174
3175 static void print_result(int alg, int run_no, int count, double time_used)
3176 {
3177     if (count == -1) {
3178         BIO_puts(bio_err, "EVP error!\n");
3179         exit(1);
3180     }
3181     BIO_printf(bio_err,
3182                mr ? "+R:%d:%s:%f\n"
3183                : "%d %s's in %.2fs\n", count, names[alg], time_used);
3184     results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
3185 }
3186
3187 #ifndef NO_FORK
3188 static char *sstrsep(char **string, const char *delim)
3189 {
3190     char isdelim[256];
3191     char *token = *string;
3192
3193     if (**string == 0)
3194         return NULL;
3195
3196     memset(isdelim, 0, sizeof(isdelim));
3197     isdelim[0] = 1;
3198
3199     while (*delim) {
3200         isdelim[(unsigned char)(*delim)] = 1;
3201         delim++;
3202     }
3203
3204     while (!isdelim[(unsigned char)(**string)]) {
3205         (*string)++;
3206     }
3207
3208     if (**string) {
3209         **string = 0;
3210         (*string)++;
3211     }
3212
3213     return token;
3214 }
3215
3216 static int do_multi(int multi, int size_num)
3217 {
3218     int n;
3219     int fd[2];
3220     int *fds;
3221     static char sep[] = ":";
3222
3223     fds = app_malloc(sizeof(*fds) * multi, "fd buffer for do_multi");
3224     for (n = 0; n < multi; ++n) {
3225         if (pipe(fd) == -1) {
3226             BIO_printf(bio_err, "pipe failure\n");
3227             exit(1);
3228         }
3229         fflush(stdout);
3230         (void)BIO_flush(bio_err);
3231         if (fork()) {
3232             close(fd[1]);
3233             fds[n] = fd[0];
3234         } else {
3235             close(fd[0]);
3236             close(1);
3237             if (dup(fd[1]) == -1) {
3238                 BIO_printf(bio_err, "dup failed\n");
3239                 exit(1);
3240             }
3241             close(fd[1]);
3242             mr = 1;
3243             usertime = 0;
3244             free(fds);
3245             return 0;
3246         }
3247         printf("Forked child %d\n", n);
3248     }
3249
3250     /* for now, assume the pipe is long enough to take all the output */
3251     for (n = 0; n < multi; ++n) {
3252         FILE *f;
3253         char buf[1024];
3254         char *p;
3255
3256         f = fdopen(fds[n], "r");
3257         while (fgets(buf, sizeof(buf), f)) {
3258             p = strchr(buf, '\n');
3259             if (p)
3260                 *p = '\0';
3261             if (buf[0] != '+') {
3262                 BIO_printf(bio_err,
3263                            "Don't understand line '%s' from child %d\n", buf,
3264                            n);
3265                 continue;
3266             }
3267             printf("Got: %s from %d\n", buf, n);
3268             if (strncmp(buf, "+F:", 3) == 0) {
3269                 int alg;
3270                 int j;
3271
3272                 p = buf + 3;
3273                 alg = atoi(sstrsep(&p, sep));
3274                 sstrsep(&p, sep);
3275                 for (j = 0; j < size_num; ++j)
3276                     results[alg][j] += atof(sstrsep(&p, sep));
3277             } else if (strncmp(buf, "+F2:", 4) == 0) {
3278                 int k;
3279                 double d;
3280
3281                 p = buf + 4;
3282                 k = atoi(sstrsep(&p, sep));
3283                 sstrsep(&p, sep);
3284
3285                 d = atof(sstrsep(&p, sep));
3286                 rsa_results[k][0] += d;
3287
3288                 d = atof(sstrsep(&p, sep));
3289                 rsa_results[k][1] += d;
3290             }
3291 # ifndef OPENSSL_NO_DSA
3292             else if (strncmp(buf, "+F3:", 4) == 0) {
3293                 int k;
3294                 double d;
3295
3296                 p = buf + 4;
3297                 k = atoi(sstrsep(&p, sep));
3298                 sstrsep(&p, sep);
3299
3300                 d = atof(sstrsep(&p, sep));
3301                 dsa_results[k][0] += d;
3302
3303                 d = atof(sstrsep(&p, sep));
3304                 dsa_results[k][1] += d;
3305             }
3306 # endif
3307 # ifndef OPENSSL_NO_EC
3308             else if (strncmp(buf, "+F4:", 4) == 0) {
3309                 int k;
3310                 double d;
3311
3312                 p = buf + 4;
3313                 k = atoi(sstrsep(&p, sep));
3314                 sstrsep(&p, sep);
3315
3316                 d = atof(sstrsep(&p, sep));
3317                 ecdsa_results[k][0] += d;
3318
3319                 d = atof(sstrsep(&p, sep));
3320                 ecdsa_results[k][1] += d;
3321             } else if (strncmp(buf, "+F5:", 4) == 0) {
3322                 int k;
3323                 double d;
3324
3325                 p = buf + 4;
3326                 k = atoi(sstrsep(&p, sep));
3327                 sstrsep(&p, sep);
3328
3329                 d = atof(sstrsep(&p, sep));
3330                 ecdh_results[k][0] += d;
3331             }
3332 # endif
3333
3334             else if (strncmp(buf, "+H:", 3) == 0) {
3335                 ;
3336             } else
3337                 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf,
3338                            n);
3339         }
3340
3341         fclose(f);
3342     }
3343     free(fds);
3344     return 1;
3345 }
3346 #endif
3347
3348 static void multiblock_speed(const EVP_CIPHER *evp_cipher, int lengths_single,
3349                              const openssl_speed_sec_t *seconds)
3350 {
3351     static const int mblengths_list[] =
3352         { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
3353     const int *mblengths = mblengths_list;
3354     int j, count, keylen, num = OSSL_NELEM(mblengths_list);
3355     const char *alg_name;
3356     unsigned char *inp, *out, *key, no_key[32], no_iv[16];
3357     EVP_CIPHER_CTX *ctx;
3358     double d = 0.0;
3359
3360     if (lengths_single) {
3361         mblengths = &lengths_single;
3362         num = 1;
3363     }
3364
3365     inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
3366     out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
3367     ctx = EVP_CIPHER_CTX_new();
3368     EVP_EncryptInit_ex(ctx, evp_cipher, NULL, NULL, no_iv);
3369
3370     keylen = EVP_CIPHER_CTX_key_length(ctx);
3371     key = app_malloc(keylen, "evp_cipher key");
3372     EVP_CIPHER_CTX_rand_key(ctx, key);
3373     EVP_EncryptInit_ex(ctx, NULL, NULL, key, NULL);
3374     OPENSSL_clear_free(key, keylen);
3375
3376     EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key), no_key);
3377     alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
3378
3379     for (j = 0; j < num; j++) {
3380         print_message(alg_name, 0, mblengths[j], seconds->sym);
3381         Time_F(START);
3382         for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
3383             unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
3384             EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
3385             size_t len = mblengths[j];
3386             int packlen;
3387
3388             memset(aad, 0, 8);  /* avoid uninitialized values */
3389             aad[8] = 23;        /* SSL3_RT_APPLICATION_DATA */
3390             aad[9] = 3;         /* version */
3391             aad[10] = 2;
3392             aad[11] = 0;        /* length */
3393             aad[12] = 0;
3394             mb_param.out = NULL;
3395             mb_param.inp = aad;
3396             mb_param.len = len;
3397             mb_param.interleave = 8;
3398
3399             packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
3400                                           sizeof(mb_param), &mb_param);
3401
3402             if (packlen > 0) {
3403                 mb_param.out = out;
3404                 mb_param.inp = inp;
3405                 mb_param.len = len;
3406                 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
3407                                     sizeof(mb_param), &mb_param);
3408             } else {
3409                 int pad;
3410
3411                 RAND_bytes(out, 16);
3412                 len += 16;
3413                 aad[11] = (unsigned char)(len >> 8);
3414                 aad[12] = (unsigned char)(len);
3415                 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
3416                                           EVP_AEAD_TLS1_AAD_LEN, aad);
3417                 EVP_Cipher(ctx, out, inp, len + pad);
3418             }
3419         }
3420         d = Time_F(STOP);
3421         BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
3422                    : "%d %s's in %.2fs\n", count, "evp", d);
3423         results[D_EVP][j] = ((double)count) / d * mblengths[j];
3424     }
3425
3426     if (mr) {
3427         fprintf(stdout, "+H");
3428         for (j = 0; j < num; j++)
3429             fprintf(stdout, ":%d", mblengths[j]);
3430         fprintf(stdout, "\n");
3431         fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
3432         for (j = 0; j < num; j++)
3433             fprintf(stdout, ":%.2f", results[D_EVP][j]);
3434         fprintf(stdout, "\n");
3435     } else {
3436         fprintf(stdout,
3437                 "The 'numbers' are in 1000s of bytes per second processed.\n");
3438         fprintf(stdout, "type                    ");
3439         for (j = 0; j < num; j++)
3440             fprintf(stdout, "%7d bytes", mblengths[j]);
3441         fprintf(stdout, "\n");
3442         fprintf(stdout, "%-24s", alg_name);
3443
3444         for (j = 0; j < num; j++) {
3445             if (results[D_EVP][j] > 10000)
3446                 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
3447             else
3448                 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
3449         }
3450         fprintf(stdout, "\n");
3451     }
3452
3453     OPENSSL_free(inp);
3454     OPENSSL_free(out);
3455     EVP_CIPHER_CTX_free(ctx);
3456 }