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