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