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