2 * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.
3 * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
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
13 #define RSA_SECONDS 10
14 #define DSA_SECONDS 10
15 #define ECDSA_SECONDS 10
16 #define ECDH_SECONDS 10
23 #include <openssl/crypto.h>
24 #include <openssl/rand.h>
25 #include <openssl/err.h>
26 #include <openssl/evp.h>
27 #include <openssl/objects.h>
28 #include <openssl/async.h>
29 #if !defined(OPENSSL_SYS_MSDOS)
30 # include OPENSSL_UNISTD
37 #include <openssl/bn.h>
38 #ifndef OPENSSL_NO_DES
39 # include <openssl/des.h>
41 #include <openssl/aes.h>
42 #ifndef OPENSSL_NO_CAMELLIA
43 # include <openssl/camellia.h>
45 #ifndef OPENSSL_NO_MD2
46 # include <openssl/md2.h>
48 #ifndef OPENSSL_NO_MDC2
49 # include <openssl/mdc2.h>
51 #ifndef OPENSSL_NO_MD4
52 # include <openssl/md4.h>
54 #ifndef OPENSSL_NO_MD5
55 # include <openssl/md5.h>
57 #include <openssl/hmac.h>
58 #include <openssl/sha.h>
59 #ifndef OPENSSL_NO_RMD160
60 # include <openssl/ripemd.h>
62 #ifndef OPENSSL_NO_WHIRLPOOL
63 # include <openssl/whrlpool.h>
65 #ifndef OPENSSL_NO_RC4
66 # include <openssl/rc4.h>
68 #ifndef OPENSSL_NO_RC5
69 # include <openssl/rc5.h>
71 #ifndef OPENSSL_NO_RC2
72 # include <openssl/rc2.h>
74 #ifndef OPENSSL_NO_IDEA
75 # include <openssl/idea.h>
77 #ifndef OPENSSL_NO_SEED
78 # include <openssl/seed.h>
81 # include <openssl/blowfish.h>
83 #ifndef OPENSSL_NO_CAST
84 # include <openssl/cast.h>
86 #ifndef OPENSSL_NO_RSA
87 # include <openssl/rsa.h>
88 # include "./testrsa.h"
90 #include <openssl/x509.h>
91 #ifndef OPENSSL_NO_DSA
92 # include <openssl/dsa.h>
93 # include "./testdsa.h"
96 # include <openssl/ec.h>
98 #include <openssl/modes.h>
101 # if defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_WINDOWS)
114 #define MAX_MISALIGNMENT 63
121 #define MAX_ECDH_SIZE 256
124 typedef struct openssl_speed_sec_st {
130 } openssl_speed_sec_t;
132 static volatile int run = 0;
135 static int usertime = 1;
137 typedef struct loopargs_st {
138 ASYNC_JOB *inprogress_job;
139 ASYNC_WAIT_CTX *wait_ctx;
142 unsigned char *buf_malloc;
143 unsigned char *buf2_malloc;
146 #ifndef OPENSSL_NO_RSA
147 RSA *rsa_key[RSA_NUM];
149 #ifndef OPENSSL_NO_DSA
150 DSA *dsa_key[DSA_NUM];
152 #ifndef OPENSSL_NO_EC
153 EC_KEY *ecdsa[EC_NUM];
154 EVP_PKEY_CTX *ecdh_ctx[EC_NUM];
155 unsigned char *secret_a;
156 unsigned char *secret_b;
157 size_t outlen[EC_NUM];
161 GCM128_CONTEXT *gcm_ctx;
164 #ifndef OPENSSL_NO_MD2
165 static int EVP_Digest_MD2_loop(void *args);
168 #ifndef OPENSSL_NO_MDC2
169 static int EVP_Digest_MDC2_loop(void *args);
171 #ifndef OPENSSL_NO_MD4
172 static int EVP_Digest_MD4_loop(void *args);
174 #ifndef OPENSSL_NO_MD5
175 static int MD5_loop(void *args);
176 static int HMAC_loop(void *args);
178 static int SHA1_loop(void *args);
179 static int SHA256_loop(void *args);
180 static int SHA512_loop(void *args);
181 #ifndef OPENSSL_NO_WHIRLPOOL
182 static int WHIRLPOOL_loop(void *args);
184 #ifndef OPENSSL_NO_RMD160
185 static int EVP_Digest_RMD160_loop(void *args);
187 #ifndef OPENSSL_NO_RC4
188 static int RC4_loop(void *args);
190 #ifndef OPENSSL_NO_DES
191 static int DES_ncbc_encrypt_loop(void *args);
192 static int DES_ede3_cbc_encrypt_loop(void *args);
194 static int AES_cbc_128_encrypt_loop(void *args);
195 static int AES_cbc_192_encrypt_loop(void *args);
196 static int AES_ige_128_encrypt_loop(void *args);
197 static int AES_cbc_256_encrypt_loop(void *args);
198 static int AES_ige_192_encrypt_loop(void *args);
199 static int AES_ige_256_encrypt_loop(void *args);
200 static int CRYPTO_gcm128_aad_loop(void *args);
201 static int RAND_bytes_loop(void *args);
202 static int EVP_Update_loop(void *args);
203 static int EVP_Update_loop_ccm(void *args);
204 static int EVP_Digest_loop(void *args);
205 #ifndef OPENSSL_NO_RSA
206 static int RSA_sign_loop(void *args);
207 static int RSA_verify_loop(void *args);
209 #ifndef OPENSSL_NO_DSA
210 static int DSA_sign_loop(void *args);
211 static int DSA_verify_loop(void *args);
213 #ifndef OPENSSL_NO_EC
214 static int ECDSA_sign_loop(void *args);
215 static int ECDSA_verify_loop(void *args);
217 static int run_benchmark(int async_jobs, int (*loop_function) (void *),
218 loopargs_t * loopargs);
220 static double Time_F(int s);
221 static void print_message(const char *s, long num, int length, int tm);
222 static void pkey_print_message(const char *str, const char *str2,
223 long num, int bits, int sec);
224 static void print_result(int alg, int run_no, int count, double time_used);
226 static int do_multi(int multi, int size_num);
229 static const int lengths_list[] = {
230 16, 64, 256, 1024, 8 * 1024, 16 * 1024
232 static int lengths_single = 0;
234 static const int *lengths = lengths_list;
236 static const char *names[ALGOR_NUM] = {
237 "md2", "mdc2", "md4", "md5", "hmac(md5)", "sha1", "rmd160", "rc4",
238 "des cbc", "des ede3", "idea cbc", "seed cbc",
239 "rc2 cbc", "rc5-32/12 cbc", "blowfish cbc", "cast cbc",
240 "aes-128 cbc", "aes-192 cbc", "aes-256 cbc",
241 "camellia-128 cbc", "camellia-192 cbc", "camellia-256 cbc",
242 "evp", "sha256", "sha512", "whirlpool",
243 "aes-128 ige", "aes-192 ige", "aes-256 ige", "ghash",
247 static double results[ALGOR_NUM][OSSL_NELEM(lengths_list)];
249 #ifndef OPENSSL_NO_RSA
250 static double rsa_results[RSA_NUM][2];
252 #ifndef OPENSSL_NO_DSA
253 static double dsa_results[DSA_NUM][2];
255 #ifndef OPENSSL_NO_EC
256 static double ecdsa_results[EC_NUM][2];
257 static double ecdh_results[EC_NUM][1];
261 # if defined(__STDC__) || defined(sgi) || defined(_AIX)
262 # define SIGRETTYPE void
264 # define SIGRETTYPE int
267 static SIGRETTYPE sig_done(int sig);
268 static SIGRETTYPE sig_done(int sig)
270 signal(SIGALRM, sig_done);
280 # if !defined(SIGALRM)
283 static unsigned int lapse;
284 static volatile unsigned int schlock;
285 static void alarm_win32(unsigned int secs)
290 # define alarm alarm_win32
292 static DWORD WINAPI sleepy(VOID * arg)
300 static double Time_F(int s)
307 thr = CreateThread(NULL, 4096, sleepy, NULL, 0, NULL);
309 DWORD err = GetLastError();
310 BIO_printf(bio_err, "unable to CreateThread (%lu)", err);
314 Sleep(0); /* scheduler spinlock */
315 ret = app_tminterval(s, usertime);
317 ret = app_tminterval(s, usertime);
319 TerminateThread(thr, 0);
327 static double Time_F(int s)
329 double ret = app_tminterval(s, usertime);
336 static void multiblock_speed(const EVP_CIPHER *evp_cipher,
337 const openssl_speed_sec_t *seconds);
339 static int found(const char *name, const OPT_PAIR *pairs, int *result)
341 for (; pairs->name; pairs++)
342 if (strcmp(name, pairs->name) == 0) {
343 *result = pairs->retval;
349 typedef enum OPTION_choice {
350 OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
351 OPT_ELAPSED, OPT_EVP, OPT_DECRYPT, OPT_ENGINE, OPT_MULTI,
352 OPT_MR, OPT_MB, OPT_MISALIGN, OPT_ASYNCJOBS, OPT_R_ENUM,
353 OPT_PRIMES, OPT_SECONDS, OPT_BYTES
356 const OPTIONS speed_options[] = {
357 {OPT_HELP_STR, 1, '-', "Usage: %s [options] ciphers...\n"},
358 {OPT_HELP_STR, 1, '-', "Valid options are:\n"},
359 {"help", OPT_HELP, '-', "Display this summary"},
360 {"evp", OPT_EVP, 's', "Use specified EVP cipher"},
361 {"decrypt", OPT_DECRYPT, '-',
362 "Time decryption instead of encryption (only EVP)"},
363 {"mr", OPT_MR, '-', "Produce machine readable output"},
365 "Enable (tls1.1) multi-block mode on evp_cipher requested with -evp"},
366 {"misalign", OPT_MISALIGN, 'n', "Amount to mis-align buffers"},
367 {"elapsed", OPT_ELAPSED, '-',
368 "Measure time in real time instead of CPU user time"},
370 {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"},
372 #ifndef OPENSSL_NO_ASYNC
373 {"async_jobs", OPT_ASYNCJOBS, 'p',
374 "Enable async mode and start pnum jobs"},
377 #ifndef OPENSSL_NO_ENGINE
378 {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
380 {"primes", OPT_PRIMES, 'p', "Specify number of primes (for RSA only)"},
381 {"seconds", OPT_SECONDS, 'p',
382 "Run benchmarks for pnum seconds"},
383 {"bytes", OPT_BYTES, 'p',
384 "Run cipher, digest and rand benchmarks on pnum bytes"},
398 #define D_CBC_IDEA 10
399 #define D_CBC_SEED 11
403 #define D_CBC_CAST 15
404 #define D_CBC_128_AES 16
405 #define D_CBC_192_AES 17
406 #define D_CBC_256_AES 18
407 #define D_CBC_128_CML 19
408 #define D_CBC_192_CML 20
409 #define D_CBC_256_CML 21
413 #define D_WHIRLPOOL 25
414 #define D_IGE_128_AES 26
415 #define D_IGE_192_AES 27
416 #define D_IGE_256_AES 28
419 static OPT_PAIR doit_choices[] = {
420 #ifndef OPENSSL_NO_MD2
423 #ifndef OPENSSL_NO_MDC2
426 #ifndef OPENSSL_NO_MD4
429 #ifndef OPENSSL_NO_MD5
434 {"sha256", D_SHA256},
435 {"sha512", D_SHA512},
436 #ifndef OPENSSL_NO_WHIRLPOOL
437 {"whirlpool", D_WHIRLPOOL},
439 #ifndef OPENSSL_NO_RMD160
440 {"ripemd", D_RMD160},
441 {"rmd160", D_RMD160},
442 {"ripemd160", D_RMD160},
444 #ifndef OPENSSL_NO_RC4
447 #ifndef OPENSSL_NO_DES
448 {"des-cbc", D_CBC_DES},
449 {"des-ede3", D_EDE3_DES},
451 {"aes-128-cbc", D_CBC_128_AES},
452 {"aes-192-cbc", D_CBC_192_AES},
453 {"aes-256-cbc", D_CBC_256_AES},
454 {"aes-128-ige", D_IGE_128_AES},
455 {"aes-192-ige", D_IGE_192_AES},
456 {"aes-256-ige", D_IGE_256_AES},
457 #ifndef OPENSSL_NO_RC2
458 {"rc2-cbc", D_CBC_RC2},
461 #ifndef OPENSSL_NO_RC5
462 {"rc5-cbc", D_CBC_RC5},
465 #ifndef OPENSSL_NO_IDEA
466 {"idea-cbc", D_CBC_IDEA},
467 {"idea", D_CBC_IDEA},
469 #ifndef OPENSSL_NO_SEED
470 {"seed-cbc", D_CBC_SEED},
471 {"seed", D_CBC_SEED},
473 #ifndef OPENSSL_NO_BF
474 {"bf-cbc", D_CBC_BF},
475 {"blowfish", D_CBC_BF},
478 #ifndef OPENSSL_NO_CAST
479 {"cast-cbc", D_CBC_CAST},
480 {"cast", D_CBC_CAST},
481 {"cast5", D_CBC_CAST},
488 #ifndef OPENSSL_NO_DSA
490 # define R_DSA_1024 1
491 # define R_DSA_2048 2
492 static OPT_PAIR dsa_choices[] = {
493 {"dsa512", R_DSA_512},
494 {"dsa1024", R_DSA_1024},
495 {"dsa2048", R_DSA_2048},
506 #define R_RSA_15360 6
507 static OPT_PAIR rsa_choices[] = {
508 {"rsa512", R_RSA_512},
509 {"rsa1024", R_RSA_1024},
510 {"rsa2048", R_RSA_2048},
511 {"rsa3072", R_RSA_3072},
512 {"rsa4096", R_RSA_4096},
513 {"rsa7680", R_RSA_7680},
514 {"rsa15360", R_RSA_15360},
534 #define R_EC_X25519 16
535 #ifndef OPENSSL_NO_EC
536 static OPT_PAIR ecdsa_choices[] = {
537 {"ecdsap160", R_EC_P160},
538 {"ecdsap192", R_EC_P192},
539 {"ecdsap224", R_EC_P224},
540 {"ecdsap256", R_EC_P256},
541 {"ecdsap384", R_EC_P384},
542 {"ecdsap521", R_EC_P521},
543 {"ecdsak163", R_EC_K163},
544 {"ecdsak233", R_EC_K233},
545 {"ecdsak283", R_EC_K283},
546 {"ecdsak409", R_EC_K409},
547 {"ecdsak571", R_EC_K571},
548 {"ecdsab163", R_EC_B163},
549 {"ecdsab233", R_EC_B233},
550 {"ecdsab283", R_EC_B283},
551 {"ecdsab409", R_EC_B409},
552 {"ecdsab571", R_EC_B571},
556 static OPT_PAIR ecdh_choices[] = {
557 {"ecdhp160", R_EC_P160},
558 {"ecdhp192", R_EC_P192},
559 {"ecdhp224", R_EC_P224},
560 {"ecdhp256", R_EC_P256},
561 {"ecdhp384", R_EC_P384},
562 {"ecdhp521", R_EC_P521},
563 {"ecdhk163", R_EC_K163},
564 {"ecdhk233", R_EC_K233},
565 {"ecdhk283", R_EC_K283},
566 {"ecdhk409", R_EC_K409},
567 {"ecdhk571", R_EC_K571},
568 {"ecdhb163", R_EC_B163},
569 {"ecdhb233", R_EC_B233},
570 {"ecdhb283", R_EC_B283},
571 {"ecdhb409", R_EC_B409},
572 {"ecdhb571", R_EC_B571},
573 {"ecdhx25519", R_EC_X25519},
579 # define COND(d) (count < (d))
580 # define COUNT(d) (d)
582 # define COND(unused_cond) (run && count<0x7fffffff)
583 # define COUNT(d) (count)
588 /* Nb of iterations to do per algorithm and key-size */
589 static long c[ALGOR_NUM][OSSL_NELEM(lengths_list)];
591 #ifndef OPENSSL_NO_MD2
592 static int EVP_Digest_MD2_loop(void *args)
594 loopargs_t *tempargs = *(loopargs_t **) args;
595 unsigned char *buf = tempargs->buf;
596 unsigned char md2[MD2_DIGEST_LENGTH];
599 for (count = 0; COND(c[D_MD2][testnum]); count++) {
600 if (!EVP_Digest(buf, (size_t)lengths[testnum], md2, NULL, EVP_md2(),
608 #ifndef OPENSSL_NO_MDC2
609 static int EVP_Digest_MDC2_loop(void *args)
611 loopargs_t *tempargs = *(loopargs_t **) args;
612 unsigned char *buf = tempargs->buf;
613 unsigned char mdc2[MDC2_DIGEST_LENGTH];
616 for (count = 0; COND(c[D_MDC2][testnum]); count++) {
617 if (!EVP_Digest(buf, (size_t)lengths[testnum], mdc2, NULL, EVP_mdc2(),
625 #ifndef OPENSSL_NO_MD4
626 static int EVP_Digest_MD4_loop(void *args)
628 loopargs_t *tempargs = *(loopargs_t **) args;
629 unsigned char *buf = tempargs->buf;
630 unsigned char md4[MD4_DIGEST_LENGTH];
633 for (count = 0; COND(c[D_MD4][testnum]); count++) {
634 if (!EVP_Digest(buf, (size_t)lengths[testnum], md4, NULL, EVP_md4(),
642 #ifndef OPENSSL_NO_MD5
643 static int MD5_loop(void *args)
645 loopargs_t *tempargs = *(loopargs_t **) args;
646 unsigned char *buf = tempargs->buf;
647 unsigned char md5[MD5_DIGEST_LENGTH];
649 for (count = 0; COND(c[D_MD5][testnum]); count++)
650 MD5(buf, lengths[testnum], md5);
654 static int HMAC_loop(void *args)
656 loopargs_t *tempargs = *(loopargs_t **) args;
657 unsigned char *buf = tempargs->buf;
658 HMAC_CTX *hctx = tempargs->hctx;
659 unsigned char hmac[MD5_DIGEST_LENGTH];
662 for (count = 0; COND(c[D_HMAC][testnum]); count++) {
663 HMAC_Init_ex(hctx, NULL, 0, NULL, NULL);
664 HMAC_Update(hctx, buf, lengths[testnum]);
665 HMAC_Final(hctx, hmac, NULL);
671 static int SHA1_loop(void *args)
673 loopargs_t *tempargs = *(loopargs_t **) args;
674 unsigned char *buf = tempargs->buf;
675 unsigned char sha[SHA_DIGEST_LENGTH];
677 for (count = 0; COND(c[D_SHA1][testnum]); count++)
678 SHA1(buf, lengths[testnum], sha);
682 static int SHA256_loop(void *args)
684 loopargs_t *tempargs = *(loopargs_t **) args;
685 unsigned char *buf = tempargs->buf;
686 unsigned char sha256[SHA256_DIGEST_LENGTH];
688 for (count = 0; COND(c[D_SHA256][testnum]); count++)
689 SHA256(buf, lengths[testnum], sha256);
693 static int SHA512_loop(void *args)
695 loopargs_t *tempargs = *(loopargs_t **) args;
696 unsigned char *buf = tempargs->buf;
697 unsigned char sha512[SHA512_DIGEST_LENGTH];
699 for (count = 0; COND(c[D_SHA512][testnum]); count++)
700 SHA512(buf, lengths[testnum], sha512);
704 #ifndef OPENSSL_NO_WHIRLPOOL
705 static int WHIRLPOOL_loop(void *args)
707 loopargs_t *tempargs = *(loopargs_t **) args;
708 unsigned char *buf = tempargs->buf;
709 unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];
711 for (count = 0; COND(c[D_WHIRLPOOL][testnum]); count++)
712 WHIRLPOOL(buf, lengths[testnum], whirlpool);
717 #ifndef OPENSSL_NO_RMD160
718 static int EVP_Digest_RMD160_loop(void *args)
720 loopargs_t *tempargs = *(loopargs_t **) args;
721 unsigned char *buf = tempargs->buf;
722 unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
724 for (count = 0; COND(c[D_RMD160][testnum]); count++) {
725 if (!EVP_Digest(buf, (size_t)lengths[testnum], &(rmd160[0]),
726 NULL, EVP_ripemd160(), NULL))
733 #ifndef OPENSSL_NO_RC4
734 static RC4_KEY rc4_ks;
735 static int RC4_loop(void *args)
737 loopargs_t *tempargs = *(loopargs_t **) args;
738 unsigned char *buf = tempargs->buf;
740 for (count = 0; COND(c[D_RC4][testnum]); count++)
741 RC4(&rc4_ks, (size_t)lengths[testnum], buf, buf);
746 #ifndef OPENSSL_NO_DES
747 static unsigned char DES_iv[8];
748 static DES_key_schedule sch;
749 static DES_key_schedule sch2;
750 static DES_key_schedule sch3;
751 static int DES_ncbc_encrypt_loop(void *args)
753 loopargs_t *tempargs = *(loopargs_t **) args;
754 unsigned char *buf = tempargs->buf;
756 for (count = 0; COND(c[D_CBC_DES][testnum]); count++)
757 DES_ncbc_encrypt(buf, buf, lengths[testnum], &sch,
758 &DES_iv, DES_ENCRYPT);
762 static int DES_ede3_cbc_encrypt_loop(void *args)
764 loopargs_t *tempargs = *(loopargs_t **) args;
765 unsigned char *buf = tempargs->buf;
767 for (count = 0; COND(c[D_EDE3_DES][testnum]); count++)
768 DES_ede3_cbc_encrypt(buf, buf, lengths[testnum],
769 &sch, &sch2, &sch3, &DES_iv, DES_ENCRYPT);
774 #define MAX_BLOCK_SIZE 128
776 static unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
777 static AES_KEY aes_ks1, aes_ks2, aes_ks3;
778 static int AES_cbc_128_encrypt_loop(void *args)
780 loopargs_t *tempargs = *(loopargs_t **) args;
781 unsigned char *buf = tempargs->buf;
783 for (count = 0; COND(c[D_CBC_128_AES][testnum]); count++)
784 AES_cbc_encrypt(buf, buf,
785 (size_t)lengths[testnum], &aes_ks1, iv, AES_ENCRYPT);
789 static int AES_cbc_192_encrypt_loop(void *args)
791 loopargs_t *tempargs = *(loopargs_t **) args;
792 unsigned char *buf = tempargs->buf;
794 for (count = 0; COND(c[D_CBC_192_AES][testnum]); count++)
795 AES_cbc_encrypt(buf, buf,
796 (size_t)lengths[testnum], &aes_ks2, iv, AES_ENCRYPT);
800 static int AES_cbc_256_encrypt_loop(void *args)
802 loopargs_t *tempargs = *(loopargs_t **) args;
803 unsigned char *buf = tempargs->buf;
805 for (count = 0; COND(c[D_CBC_256_AES][testnum]); count++)
806 AES_cbc_encrypt(buf, buf,
807 (size_t)lengths[testnum], &aes_ks3, iv, AES_ENCRYPT);
811 static int AES_ige_128_encrypt_loop(void *args)
813 loopargs_t *tempargs = *(loopargs_t **) args;
814 unsigned char *buf = tempargs->buf;
815 unsigned char *buf2 = tempargs->buf2;
817 for (count = 0; COND(c[D_IGE_128_AES][testnum]); count++)
818 AES_ige_encrypt(buf, buf2,
819 (size_t)lengths[testnum], &aes_ks1, iv, AES_ENCRYPT);
823 static int AES_ige_192_encrypt_loop(void *args)
825 loopargs_t *tempargs = *(loopargs_t **) args;
826 unsigned char *buf = tempargs->buf;
827 unsigned char *buf2 = tempargs->buf2;
829 for (count = 0; COND(c[D_IGE_192_AES][testnum]); count++)
830 AES_ige_encrypt(buf, buf2,
831 (size_t)lengths[testnum], &aes_ks2, iv, AES_ENCRYPT);
835 static int AES_ige_256_encrypt_loop(void *args)
837 loopargs_t *tempargs = *(loopargs_t **) args;
838 unsigned char *buf = tempargs->buf;
839 unsigned char *buf2 = tempargs->buf2;
841 for (count = 0; COND(c[D_IGE_256_AES][testnum]); count++)
842 AES_ige_encrypt(buf, buf2,
843 (size_t)lengths[testnum], &aes_ks3, iv, AES_ENCRYPT);
847 static int CRYPTO_gcm128_aad_loop(void *args)
849 loopargs_t *tempargs = *(loopargs_t **) args;
850 unsigned char *buf = tempargs->buf;
851 GCM128_CONTEXT *gcm_ctx = tempargs->gcm_ctx;
853 for (count = 0; COND(c[D_GHASH][testnum]); count++)
854 CRYPTO_gcm128_aad(gcm_ctx, buf, lengths[testnum]);
858 static int RAND_bytes_loop(void *args)
860 loopargs_t *tempargs = *(loopargs_t **) args;
861 unsigned char *buf = tempargs->buf;
864 for (count = 0; COND(c[D_RAND][testnum]); count++)
865 RAND_bytes(buf, lengths[testnum]);
869 static long save_count = 0;
870 static int decrypt = 0;
871 static int EVP_Update_loop(void *args)
873 loopargs_t *tempargs = *(loopargs_t **) args;
874 unsigned char *buf = tempargs->buf;
875 EVP_CIPHER_CTX *ctx = tempargs->ctx;
878 int nb_iter = save_count * 4 * lengths[0] / lengths[testnum];
881 for (count = 0; COND(nb_iter); count++) {
882 rc = EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
884 EVP_CipherInit_ex(ctx, NULL, NULL, NULL, iv, -1);
887 for (count = 0; COND(nb_iter); count++) {
888 rc = EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
890 EVP_CipherInit_ex(ctx, NULL, NULL, NULL, iv, -1);
894 EVP_DecryptFinal_ex(ctx, buf, &outl);
896 EVP_EncryptFinal_ex(ctx, buf, &outl);
900 * CCM does not support streaming. For the purpose of performance measurement,
901 * each message is encrypted using the same (key,iv)-pair. Do not use this
902 * code in your application.
904 static int EVP_Update_loop_ccm(void *args)
906 loopargs_t *tempargs = *(loopargs_t **) args;
907 unsigned char *buf = tempargs->buf;
908 EVP_CIPHER_CTX *ctx = tempargs->ctx;
910 unsigned char tag[12];
912 int nb_iter = save_count * 4 * lengths[0] / lengths[testnum];
915 for (count = 0; COND(nb_iter); count++) {
916 EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, iv);
917 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, sizeof(tag), tag);
918 EVP_DecryptUpdate(ctx, NULL, &outl, NULL, lengths[testnum]);
919 EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
920 EVP_DecryptFinal_ex(ctx, buf, &outl);
923 for (count = 0; COND(nb_iter); count++) {
924 EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv);
925 EVP_EncryptUpdate(ctx, NULL, &outl, NULL, lengths[testnum]);
926 EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
927 EVP_EncryptFinal_ex(ctx, buf, &outl);
933 static const EVP_MD *evp_md = NULL;
934 static int EVP_Digest_loop(void *args)
936 loopargs_t *tempargs = *(loopargs_t **) args;
937 unsigned char *buf = tempargs->buf;
938 unsigned char md[EVP_MAX_MD_SIZE];
941 int nb_iter = save_count * 4 * lengths[0] / lengths[testnum];
944 for (count = 0; COND(nb_iter); count++) {
945 if (!EVP_Digest(buf, lengths[testnum], md, NULL, evp_md, NULL))
951 #ifndef OPENSSL_NO_RSA
952 static long rsa_c[RSA_NUM][2]; /* # RSA iteration test */
954 static int RSA_sign_loop(void *args)
956 loopargs_t *tempargs = *(loopargs_t **) args;
957 unsigned char *buf = tempargs->buf;
958 unsigned char *buf2 = tempargs->buf2;
959 unsigned int *rsa_num = &tempargs->siglen;
960 RSA **rsa_key = tempargs->rsa_key;
962 for (count = 0; COND(rsa_c[testnum][0]); count++) {
963 ret = RSA_sign(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
965 BIO_printf(bio_err, "RSA sign failure\n");
966 ERR_print_errors(bio_err);
974 static int RSA_verify_loop(void *args)
976 loopargs_t *tempargs = *(loopargs_t **) args;
977 unsigned char *buf = tempargs->buf;
978 unsigned char *buf2 = tempargs->buf2;
979 unsigned int rsa_num = tempargs->siglen;
980 RSA **rsa_key = tempargs->rsa_key;
982 for (count = 0; COND(rsa_c[testnum][1]); count++) {
984 RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
986 BIO_printf(bio_err, "RSA verify failure\n");
987 ERR_print_errors(bio_err);
996 #ifndef OPENSSL_NO_DSA
997 static long dsa_c[DSA_NUM][2];
998 static int DSA_sign_loop(void *args)
1000 loopargs_t *tempargs = *(loopargs_t **) args;
1001 unsigned char *buf = tempargs->buf;
1002 unsigned char *buf2 = tempargs->buf2;
1003 DSA **dsa_key = tempargs->dsa_key;
1004 unsigned int *siglen = &tempargs->siglen;
1006 for (count = 0; COND(dsa_c[testnum][0]); count++) {
1007 ret = DSA_sign(0, buf, 20, buf2, siglen, dsa_key[testnum]);
1009 BIO_printf(bio_err, "DSA sign failure\n");
1010 ERR_print_errors(bio_err);
1018 static int DSA_verify_loop(void *args)
1020 loopargs_t *tempargs = *(loopargs_t **) args;
1021 unsigned char *buf = tempargs->buf;
1022 unsigned char *buf2 = tempargs->buf2;
1023 DSA **dsa_key = tempargs->dsa_key;
1024 unsigned int siglen = tempargs->siglen;
1026 for (count = 0; COND(dsa_c[testnum][1]); count++) {
1027 ret = DSA_verify(0, buf, 20, buf2, siglen, dsa_key[testnum]);
1029 BIO_printf(bio_err, "DSA verify failure\n");
1030 ERR_print_errors(bio_err);
1039 #ifndef OPENSSL_NO_EC
1040 static long ecdsa_c[EC_NUM][2];
1041 static int ECDSA_sign_loop(void *args)
1043 loopargs_t *tempargs = *(loopargs_t **) args;
1044 unsigned char *buf = tempargs->buf;
1045 EC_KEY **ecdsa = tempargs->ecdsa;
1046 unsigned char *ecdsasig = tempargs->buf2;
1047 unsigned int *ecdsasiglen = &tempargs->siglen;
1049 for (count = 0; COND(ecdsa_c[testnum][0]); count++) {
1050 ret = ECDSA_sign(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[testnum]);
1052 BIO_printf(bio_err, "ECDSA sign failure\n");
1053 ERR_print_errors(bio_err);
1061 static int ECDSA_verify_loop(void *args)
1063 loopargs_t *tempargs = *(loopargs_t **) args;
1064 unsigned char *buf = tempargs->buf;
1065 EC_KEY **ecdsa = tempargs->ecdsa;
1066 unsigned char *ecdsasig = tempargs->buf2;
1067 unsigned int ecdsasiglen = tempargs->siglen;
1069 for (count = 0; COND(ecdsa_c[testnum][1]); count++) {
1070 ret = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[testnum]);
1072 BIO_printf(bio_err, "ECDSA verify failure\n");
1073 ERR_print_errors(bio_err);
1081 /* ******************************************************************** */
1082 static long ecdh_c[EC_NUM][1];
1084 static int ECDH_EVP_derive_key_loop(void *args)
1086 loopargs_t *tempargs = *(loopargs_t **) args;
1087 EVP_PKEY_CTX *ctx = tempargs->ecdh_ctx[testnum];
1088 unsigned char *derived_secret = tempargs->secret_a;
1090 size_t *outlen = &(tempargs->outlen[testnum]);
1092 for (count = 0; COND(ecdh_c[testnum][0]); count++)
1093 EVP_PKEY_derive(ctx, derived_secret, outlen);
1098 #endif /* OPENSSL_NO_EC */
1100 static int run_benchmark(int async_jobs,
1101 int (*loop_function) (void *), loopargs_t * loopargs)
1103 int job_op_count = 0;
1104 int total_op_count = 0;
1105 int num_inprogress = 0;
1106 int error = 0, i = 0, ret = 0;
1107 OSSL_ASYNC_FD job_fd = 0;
1108 size_t num_job_fds = 0;
1112 if (async_jobs == 0) {
1113 return loop_function((void *)&loopargs);
1116 for (i = 0; i < async_jobs && !error; i++) {
1117 loopargs_t *looparg_item = loopargs + i;
1119 /* Copy pointer content (looparg_t item address) into async context */
1120 ret = ASYNC_start_job(&loopargs[i].inprogress_job, loopargs[i].wait_ctx,
1121 &job_op_count, loop_function,
1122 (void *)&looparg_item, sizeof(looparg_item));
1128 if (job_op_count == -1) {
1131 total_op_count += job_op_count;
1136 BIO_printf(bio_err, "Failure in the job\n");
1137 ERR_print_errors(bio_err);
1143 while (num_inprogress > 0) {
1144 #if defined(OPENSSL_SYS_WINDOWS)
1146 #elif defined(OPENSSL_SYS_UNIX)
1147 int select_result = 0;
1148 OSSL_ASYNC_FD max_fd = 0;
1151 FD_ZERO(&waitfdset);
1153 for (i = 0; i < async_jobs && num_inprogress > 0; i++) {
1154 if (loopargs[i].inprogress_job == NULL)
1157 if (!ASYNC_WAIT_CTX_get_all_fds
1158 (loopargs[i].wait_ctx, NULL, &num_job_fds)
1159 || num_job_fds > 1) {
1160 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1161 ERR_print_errors(bio_err);
1165 ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd,
1167 FD_SET(job_fd, &waitfdset);
1168 if (job_fd > max_fd)
1172 if (max_fd >= (OSSL_ASYNC_FD)FD_SETSIZE) {
1174 "Error: max_fd (%d) must be smaller than FD_SETSIZE (%d). "
1175 "Decrease the value of async_jobs\n",
1176 max_fd, FD_SETSIZE);
1177 ERR_print_errors(bio_err);
1182 select_result = select(max_fd + 1, &waitfdset, NULL, NULL, NULL);
1183 if (select_result == -1 && errno == EINTR)
1186 if (select_result == -1) {
1187 BIO_printf(bio_err, "Failure in the select\n");
1188 ERR_print_errors(bio_err);
1193 if (select_result == 0)
1197 for (i = 0; i < async_jobs; i++) {
1198 if (loopargs[i].inprogress_job == NULL)
1201 if (!ASYNC_WAIT_CTX_get_all_fds
1202 (loopargs[i].wait_ctx, NULL, &num_job_fds)
1203 || num_job_fds > 1) {
1204 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1205 ERR_print_errors(bio_err);
1209 ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd,
1212 #if defined(OPENSSL_SYS_UNIX)
1213 if (num_job_fds == 1 && !FD_ISSET(job_fd, &waitfdset))
1215 #elif defined(OPENSSL_SYS_WINDOWS)
1216 if (num_job_fds == 1
1217 && !PeekNamedPipe(job_fd, NULL, 0, NULL, &avail, NULL)
1222 ret = ASYNC_start_job(&loopargs[i].inprogress_job,
1223 loopargs[i].wait_ctx, &job_op_count,
1224 loop_function, (void *)(loopargs + i),
1225 sizeof(loopargs_t));
1230 if (job_op_count == -1) {
1233 total_op_count += job_op_count;
1236 loopargs[i].inprogress_job = NULL;
1241 loopargs[i].inprogress_job = NULL;
1242 BIO_printf(bio_err, "Failure in the job\n");
1243 ERR_print_errors(bio_err);
1250 return error ? -1 : total_op_count;
1253 int speed_main(int argc, char **argv)
1256 int (*loopfunc)(void *args);
1257 loopargs_t *loopargs = NULL;
1259 int loopargs_len = 0;
1261 const char *engine_id = NULL;
1262 const EVP_CIPHER *evp_cipher = NULL;
1265 int multiblock = 0, pr_header = 0;
1266 int doit[ALGOR_NUM] = { 0 };
1267 int ret = 1, i, k, misalign = 0;
1269 int size_num = OSSL_NELEM(lengths_list);
1275 unsigned int async_jobs = 0;
1276 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) \
1277 || !defined(OPENSSL_NO_EC)
1282 /* What follows are the buffers and key material. */
1283 #ifndef OPENSSL_NO_RC5
1286 #ifndef OPENSSL_NO_RC2
1289 #ifndef OPENSSL_NO_IDEA
1290 IDEA_KEY_SCHEDULE idea_ks;
1292 #ifndef OPENSSL_NO_SEED
1293 SEED_KEY_SCHEDULE seed_ks;
1295 #ifndef OPENSSL_NO_BF
1298 #ifndef OPENSSL_NO_CAST
1301 static const unsigned char key16[16] = {
1302 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1303 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1305 static const unsigned char key24[24] = {
1306 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1307 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1308 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1310 static const unsigned char key32[32] = {
1311 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1312 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1313 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1314 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1316 #ifndef OPENSSL_NO_CAMELLIA
1317 static const unsigned char ckey24[24] = {
1318 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1319 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1320 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1322 static const unsigned char ckey32[32] = {
1323 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1324 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1325 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1326 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1328 CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
1330 #ifndef OPENSSL_NO_DES
1331 static DES_cblock key = {
1332 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
1334 static DES_cblock key2 = {
1335 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1337 static DES_cblock key3 = {
1338 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1341 #ifndef OPENSSL_NO_RSA
1342 static const unsigned int rsa_bits[RSA_NUM] = {
1343 512, 1024, 2048, 3072, 4096, 7680, 15360
1345 static const unsigned char *rsa_data[RSA_NUM] = {
1346 test512, test1024, test2048, test3072, test4096, test7680, test15360
1348 static const int rsa_data_length[RSA_NUM] = {
1349 sizeof(test512), sizeof(test1024),
1350 sizeof(test2048), sizeof(test3072),
1351 sizeof(test4096), sizeof(test7680),
1354 int rsa_doit[RSA_NUM] = { 0 };
1355 int primes = RSA_DEFAULT_PRIME_NUM;
1357 #ifndef OPENSSL_NO_DSA
1358 static const unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
1359 int dsa_doit[DSA_NUM] = { 0 };
1361 #ifndef OPENSSL_NO_EC
1363 * We only test over the following curves as they are representative, To
1364 * add tests over more curves, simply add the curve NID and curve name to
1365 * the following arrays and increase the EC_NUM value accordingly.
1367 static const unsigned int test_curves[EC_NUM] = {
1369 NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
1370 NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
1372 NID_sect163k1, NID_sect233k1, NID_sect283k1,
1373 NID_sect409k1, NID_sect571k1, NID_sect163r2,
1374 NID_sect233r1, NID_sect283r1, NID_sect409r1,
1379 static const char *test_curves_names[EC_NUM] = {
1381 "secp160r1", "nistp192", "nistp224",
1382 "nistp256", "nistp384", "nistp521",
1384 "nistk163", "nistk233", "nistk283",
1385 "nistk409", "nistk571", "nistb163",
1386 "nistb233", "nistb283", "nistb409",
1391 static const int test_curves_bits[EC_NUM] = {
1397 571, 253 /* X25519 */
1400 int ecdsa_doit[EC_NUM] = { 0 };
1401 int ecdh_doit[EC_NUM] = { 0 };
1402 #endif /* ndef OPENSSL_NO_EC */
1404 openssl_speed_sec_t seconds = { SECONDS, RSA_SECONDS, DSA_SECONDS,
1405 ECDSA_SECONDS, ECDH_SECONDS };
1407 prog = opt_init(argc, argv, speed_options);
1408 while ((o = opt_next()) != OPT_EOF) {
1413 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
1416 opt_help(speed_options);
1424 evp_cipher = EVP_get_cipherbyname(opt_arg());
1425 if (evp_cipher == NULL)
1426 evp_md = EVP_get_digestbyname(opt_arg());
1427 if (evp_cipher == NULL && evp_md == NULL) {
1429 "%s: %s is an unknown cipher or digest\n",
1440 * In a forked execution, an engine might need to be
1441 * initialised by each child process, not by the parent.
1442 * So store the name here and run setup_engine() later on.
1444 engine_id = opt_arg();
1448 multi = atoi(opt_arg());
1452 #ifndef OPENSSL_NO_ASYNC
1453 async_jobs = atoi(opt_arg());
1454 if (!ASYNC_is_capable()) {
1456 "%s: async_jobs specified but async not supported\n",
1460 if (async_jobs > 99999) {
1462 "%s: too many async_jobs\n",
1469 if (!opt_int(opt_arg(), &misalign))
1471 if (misalign > MISALIGN) {
1473 "%s: Maximum offset is %d\n", prog, MISALIGN);
1482 #ifdef OPENSSL_NO_MULTIBLOCK
1484 "%s: -mb specified but multi-block support is disabled\n",
1494 if (!opt_int(opt_arg(), &primes))
1498 seconds.sym = seconds.rsa = seconds.dsa = seconds.ecdsa
1499 = seconds.ecdh = atoi(opt_arg());
1502 lengths_single = atoi(opt_arg());
1503 lengths = &lengths_single;
1508 argc = opt_num_rest();
1511 /* Remaining arguments are algorithms. */
1512 for (; *argv; argv++) {
1513 if (found(*argv, doit_choices, &i)) {
1517 #ifndef OPENSSL_NO_DES
1518 if (strcmp(*argv, "des") == 0) {
1519 doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
1523 if (strcmp(*argv, "sha") == 0) {
1524 doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
1527 #ifndef OPENSSL_NO_RSA
1528 if (strcmp(*argv, "openssl") == 0)
1530 if (strcmp(*argv, "rsa") == 0) {
1531 rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
1532 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
1533 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
1534 rsa_doit[R_RSA_15360] = 1;
1537 if (found(*argv, rsa_choices, &i)) {
1542 #ifndef OPENSSL_NO_DSA
1543 if (strcmp(*argv, "dsa") == 0) {
1544 dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
1545 dsa_doit[R_DSA_2048] = 1;
1548 if (found(*argv, dsa_choices, &i)) {
1553 if (strcmp(*argv, "aes") == 0) {
1554 doit[D_CBC_128_AES] = doit[D_CBC_192_AES] = doit[D_CBC_256_AES] = 1;
1557 #ifndef OPENSSL_NO_CAMELLIA
1558 if (strcmp(*argv, "camellia") == 0) {
1559 doit[D_CBC_128_CML] = doit[D_CBC_192_CML] = doit[D_CBC_256_CML] = 1;
1563 #ifndef OPENSSL_NO_EC
1564 if (strcmp(*argv, "ecdsa") == 0) {
1565 for (loop = 0; loop < OSSL_NELEM(ecdsa_choices); loop++)
1566 ecdsa_doit[ecdsa_choices[loop].retval] = 1;
1569 if (found(*argv, ecdsa_choices, &i)) {
1573 if (strcmp(*argv, "ecdh") == 0) {
1574 for (loop = 0; loop < OSSL_NELEM(ecdh_choices); loop++)
1575 ecdh_doit[ecdh_choices[loop].retval] = 1;
1578 if (found(*argv, ecdh_choices, &i)) {
1583 BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
1587 /* Initialize the job pool if async mode is enabled */
1588 if (async_jobs > 0) {
1589 async_init = ASYNC_init_thread(async_jobs, async_jobs);
1591 BIO_printf(bio_err, "Error creating the ASYNC job pool\n");
1596 loopargs_len = (async_jobs == 0 ? 1 : async_jobs);
1598 app_malloc(loopargs_len * sizeof(loopargs_t), "array of loopargs");
1599 memset(loopargs, 0, loopargs_len * sizeof(loopargs_t));
1601 for (i = 0; i < loopargs_len; i++) {
1602 if (async_jobs > 0) {
1603 loopargs[i].wait_ctx = ASYNC_WAIT_CTX_new();
1604 if (loopargs[i].wait_ctx == NULL) {
1605 BIO_printf(bio_err, "Error creating the ASYNC_WAIT_CTX\n");
1610 buflen = lengths[size_num - 1] + MAX_MISALIGNMENT + 1;
1611 loopargs[i].buf_malloc = app_malloc(buflen, "input buffer");
1612 loopargs[i].buf2_malloc = app_malloc(buflen, "input buffer");
1613 memset(loopargs[i].buf_malloc, 0, buflen);
1614 memset(loopargs[i].buf2_malloc, 0, buflen);
1616 /* Align the start of buffers on a 64 byte boundary */
1617 loopargs[i].buf = loopargs[i].buf_malloc + misalign;
1618 loopargs[i].buf2 = loopargs[i].buf2_malloc + misalign;
1619 #ifndef OPENSSL_NO_EC
1620 loopargs[i].secret_a = app_malloc(MAX_ECDH_SIZE, "ECDH secret a");
1621 loopargs[i].secret_b = app_malloc(MAX_ECDH_SIZE, "ECDH secret b");
1626 if (multi && do_multi(multi, size_num))
1630 /* Initialize the engine after the fork */
1631 e = setup_engine(engine_id, 0);
1633 /* No parameters; turn on everything. */
1634 if ((argc == 0) && !doit[D_EVP]) {
1635 for (i = 0; i < ALGOR_NUM; i++)
1638 #ifndef OPENSSL_NO_RSA
1639 for (i = 0; i < RSA_NUM; i++)
1642 #ifndef OPENSSL_NO_DSA
1643 for (i = 0; i < DSA_NUM; i++)
1646 #ifndef OPENSSL_NO_EC
1647 for (loop = 0; loop < OSSL_NELEM(ecdsa_choices); loop++)
1648 ecdsa_doit[ecdsa_choices[loop].retval] = 1;
1649 for (loop = 0; loop < OSSL_NELEM(ecdh_choices); loop++)
1650 ecdh_doit[ecdh_choices[loop].retval] = 1;
1653 for (i = 0; i < ALGOR_NUM; i++)
1657 if (usertime == 0 && !mr)
1659 "You have chosen to measure elapsed time "
1660 "instead of user CPU time.\n");
1662 #ifndef OPENSSL_NO_RSA
1663 for (i = 0; i < loopargs_len; i++) {
1664 if (primes > RSA_DEFAULT_PRIME_NUM) {
1665 /* for multi-prime RSA, skip this */
1668 for (k = 0; k < RSA_NUM; k++) {
1669 const unsigned char *p;
1672 loopargs[i].rsa_key[k] =
1673 d2i_RSAPrivateKey(NULL, &p, rsa_data_length[k]);
1674 if (loopargs[i].rsa_key[k] == NULL) {
1676 "internal error loading RSA key number %d\n", k);
1682 #ifndef OPENSSL_NO_DSA
1683 for (i = 0; i < loopargs_len; i++) {
1684 loopargs[i].dsa_key[0] = get_dsa(512);
1685 loopargs[i].dsa_key[1] = get_dsa(1024);
1686 loopargs[i].dsa_key[2] = get_dsa(2048);
1689 #ifndef OPENSSL_NO_DES
1690 DES_set_key_unchecked(&key, &sch);
1691 DES_set_key_unchecked(&key2, &sch2);
1692 DES_set_key_unchecked(&key3, &sch3);
1694 AES_set_encrypt_key(key16, 128, &aes_ks1);
1695 AES_set_encrypt_key(key24, 192, &aes_ks2);
1696 AES_set_encrypt_key(key32, 256, &aes_ks3);
1697 #ifndef OPENSSL_NO_CAMELLIA
1698 Camellia_set_key(key16, 128, &camellia_ks1);
1699 Camellia_set_key(ckey24, 192, &camellia_ks2);
1700 Camellia_set_key(ckey32, 256, &camellia_ks3);
1702 #ifndef OPENSSL_NO_IDEA
1703 IDEA_set_encrypt_key(key16, &idea_ks);
1705 #ifndef OPENSSL_NO_SEED
1706 SEED_set_key(key16, &seed_ks);
1708 #ifndef OPENSSL_NO_RC4
1709 RC4_set_key(&rc4_ks, 16, key16);
1711 #ifndef OPENSSL_NO_RC2
1712 RC2_set_key(&rc2_ks, 16, key16, 128);
1714 #ifndef OPENSSL_NO_RC5
1715 RC5_32_set_key(&rc5_ks, 16, key16, 12);
1717 #ifndef OPENSSL_NO_BF
1718 BF_set_key(&bf_ks, 16, key16);
1720 #ifndef OPENSSL_NO_CAST
1721 CAST_set_key(&cast_ks, 16, key16);
1724 # ifndef OPENSSL_NO_DES
1725 BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1731 for (it = count; it; it--)
1732 DES_ecb_encrypt((DES_cblock *)loopargs[0].buf,
1733 (DES_cblock *)loopargs[0].buf, &sch, DES_ENCRYPT);
1737 c[D_MD2][0] = count / 10;
1738 c[D_MDC2][0] = count / 10;
1739 c[D_MD4][0] = count;
1740 c[D_MD5][0] = count;
1741 c[D_HMAC][0] = count;
1742 c[D_SHA1][0] = count;
1743 c[D_RMD160][0] = count;
1744 c[D_RC4][0] = count * 5;
1745 c[D_CBC_DES][0] = count;
1746 c[D_EDE3_DES][0] = count / 3;
1747 c[D_CBC_IDEA][0] = count;
1748 c[D_CBC_SEED][0] = count;
1749 c[D_CBC_RC2][0] = count;
1750 c[D_CBC_RC5][0] = count;
1751 c[D_CBC_BF][0] = count;
1752 c[D_CBC_CAST][0] = count;
1753 c[D_CBC_128_AES][0] = count;
1754 c[D_CBC_192_AES][0] = count;
1755 c[D_CBC_256_AES][0] = count;
1756 c[D_CBC_128_CML][0] = count;
1757 c[D_CBC_192_CML][0] = count;
1758 c[D_CBC_256_CML][0] = count;
1759 c[D_SHA256][0] = count;
1760 c[D_SHA512][0] = count;
1761 c[D_WHIRLPOOL][0] = count;
1762 c[D_IGE_128_AES][0] = count;
1763 c[D_IGE_192_AES][0] = count;
1764 c[D_IGE_256_AES][0] = count;
1765 c[D_GHASH][0] = count;
1766 c[D_RAND][0] = count;
1768 for (i = 1; i < size_num; i++) {
1771 l0 = (long)lengths[0];
1772 l1 = (long)lengths[i];
1774 c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1775 c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1776 c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1777 c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1778 c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1779 c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1780 c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1781 c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1782 c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1783 c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1784 c[D_GHASH][i] = c[D_GHASH][0] * 4 * l0 / l1;
1785 c[D_RAND][i] = c[D_RAND][0] * 4 * l0 / l1;
1787 l0 = (long)lengths[i - 1];
1789 c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1790 c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1791 c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1792 c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1793 c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1794 c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1795 c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1796 c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1797 c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1798 c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1799 c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1800 c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1801 c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1802 c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1803 c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1804 c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1805 c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1806 c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1809 # ifndef OPENSSL_NO_RSA
1810 rsa_c[R_RSA_512][0] = count / 2000;
1811 rsa_c[R_RSA_512][1] = count / 400;
1812 for (i = 1; i < RSA_NUM; i++) {
1813 rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1814 rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1815 if (rsa_doit[i] <= 1 && rsa_c[i][0] == 0)
1818 if (rsa_c[i][0] == 0) {
1819 rsa_c[i][0] = 1; /* Set minimum iteration Nb to 1. */
1826 # ifndef OPENSSL_NO_DSA
1827 dsa_c[R_DSA_512][0] = count / 1000;
1828 dsa_c[R_DSA_512][1] = count / 1000 / 2;
1829 for (i = 1; i < DSA_NUM; i++) {
1830 dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1831 dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1832 if (dsa_doit[i] <= 1 && dsa_c[i][0] == 0)
1835 if (dsa_c[i][0] == 0) {
1836 dsa_c[i][0] = 1; /* Set minimum iteration Nb to 1. */
1843 # ifndef OPENSSL_NO_EC
1844 ecdsa_c[R_EC_P160][0] = count / 1000;
1845 ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1846 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1847 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1848 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1849 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1852 if (ecdsa_c[i][0] == 0) {
1858 ecdsa_c[R_EC_K163][0] = count / 1000;
1859 ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1860 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1861 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1862 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1863 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1866 if (ecdsa_c[i][0] == 0) {
1872 ecdsa_c[R_EC_B163][0] = count / 1000;
1873 ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1874 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1875 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1876 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1877 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1880 if (ecdsa_c[i][0] == 0) {
1887 ecdh_c[R_EC_P160][0] = count / 1000;
1888 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1889 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1890 if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1893 if (ecdh_c[i][0] == 0) {
1898 ecdh_c[R_EC_K163][0] = count / 1000;
1899 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1900 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1901 if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1904 if (ecdh_c[i][0] == 0) {
1909 ecdh_c[R_EC_B163][0] = count / 1000;
1910 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1911 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1912 if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1915 if (ecdh_c[i][0] == 0) {
1923 /* not worth fixing */
1924 # error "You cannot disable DES on systems without SIGALRM."
1925 # endif /* OPENSSL_NO_DES */
1928 signal(SIGALRM, sig_done);
1930 #endif /* SIGALRM */
1932 #ifndef OPENSSL_NO_MD2
1934 for (testnum = 0; testnum < size_num; testnum++) {
1935 print_message(names[D_MD2], c[D_MD2][testnum], lengths[testnum],
1938 count = run_benchmark(async_jobs, EVP_Digest_MD2_loop, loopargs);
1940 print_result(D_MD2, testnum, count, d);
1944 #ifndef OPENSSL_NO_MDC2
1946 for (testnum = 0; testnum < size_num; testnum++) {
1947 print_message(names[D_MDC2], c[D_MDC2][testnum], lengths[testnum],
1950 count = run_benchmark(async_jobs, EVP_Digest_MDC2_loop, loopargs);
1952 print_result(D_MDC2, testnum, count, d);
1957 #ifndef OPENSSL_NO_MD4
1959 for (testnum = 0; testnum < size_num; testnum++) {
1960 print_message(names[D_MD4], c[D_MD4][testnum], lengths[testnum],
1963 count = run_benchmark(async_jobs, EVP_Digest_MD4_loop, loopargs);
1965 print_result(D_MD4, testnum, count, d);
1970 #ifndef OPENSSL_NO_MD5
1972 for (testnum = 0; testnum < size_num; testnum++) {
1973 print_message(names[D_MD5], c[D_MD5][testnum], lengths[testnum],
1976 count = run_benchmark(async_jobs, MD5_loop, loopargs);
1978 print_result(D_MD5, testnum, count, d);
1983 static const char hmac_key[] = "This is a key...";
1984 int len = strlen(hmac_key);
1986 for (i = 0; i < loopargs_len; i++) {
1987 loopargs[i].hctx = HMAC_CTX_new();
1988 if (loopargs[i].hctx == NULL) {
1989 BIO_printf(bio_err, "HMAC malloc failure, exiting...");
1993 HMAC_Init_ex(loopargs[i].hctx, hmac_key, len, EVP_md5(), NULL);
1995 for (testnum = 0; testnum < size_num; testnum++) {
1996 print_message(names[D_HMAC], c[D_HMAC][testnum], lengths[testnum],
1999 count = run_benchmark(async_jobs, HMAC_loop, loopargs);
2001 print_result(D_HMAC, testnum, count, d);
2003 for (i = 0; i < loopargs_len; i++) {
2004 HMAC_CTX_free(loopargs[i].hctx);
2009 for (testnum = 0; testnum < size_num; testnum++) {
2010 print_message(names[D_SHA1], c[D_SHA1][testnum], lengths[testnum],
2013 count = run_benchmark(async_jobs, SHA1_loop, loopargs);
2015 print_result(D_SHA1, testnum, count, d);
2018 if (doit[D_SHA256]) {
2019 for (testnum = 0; testnum < size_num; testnum++) {
2020 print_message(names[D_SHA256], c[D_SHA256][testnum],
2021 lengths[testnum], seconds.sym);
2023 count = run_benchmark(async_jobs, SHA256_loop, loopargs);
2025 print_result(D_SHA256, testnum, count, d);
2028 if (doit[D_SHA512]) {
2029 for (testnum = 0; testnum < size_num; testnum++) {
2030 print_message(names[D_SHA512], c[D_SHA512][testnum],
2031 lengths[testnum], seconds.sym);
2033 count = run_benchmark(async_jobs, SHA512_loop, loopargs);
2035 print_result(D_SHA512, testnum, count, d);
2038 #ifndef OPENSSL_NO_WHIRLPOOL
2039 if (doit[D_WHIRLPOOL]) {
2040 for (testnum = 0; testnum < size_num; testnum++) {
2041 print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][testnum],
2042 lengths[testnum], seconds.sym);
2044 count = run_benchmark(async_jobs, WHIRLPOOL_loop, loopargs);
2046 print_result(D_WHIRLPOOL, testnum, count, d);
2051 #ifndef OPENSSL_NO_RMD160
2052 if (doit[D_RMD160]) {
2053 for (testnum = 0; testnum < size_num; testnum++) {
2054 print_message(names[D_RMD160], c[D_RMD160][testnum],
2055 lengths[testnum], seconds.sym);
2057 count = run_benchmark(async_jobs, EVP_Digest_RMD160_loop, loopargs);
2059 print_result(D_RMD160, testnum, count, d);
2063 #ifndef OPENSSL_NO_RC4
2065 for (testnum = 0; testnum < size_num; testnum++) {
2066 print_message(names[D_RC4], c[D_RC4][testnum], lengths[testnum],
2069 count = run_benchmark(async_jobs, RC4_loop, loopargs);
2071 print_result(D_RC4, testnum, count, d);
2075 #ifndef OPENSSL_NO_DES
2076 if (doit[D_CBC_DES]) {
2077 for (testnum = 0; testnum < size_num; testnum++) {
2078 print_message(names[D_CBC_DES], c[D_CBC_DES][testnum],
2079 lengths[testnum], seconds.sym);
2081 count = run_benchmark(async_jobs, DES_ncbc_encrypt_loop, loopargs);
2083 print_result(D_CBC_DES, testnum, count, d);
2087 if (doit[D_EDE3_DES]) {
2088 for (testnum = 0; testnum < size_num; testnum++) {
2089 print_message(names[D_EDE3_DES], c[D_EDE3_DES][testnum],
2090 lengths[testnum], seconds.sym);
2093 run_benchmark(async_jobs, DES_ede3_cbc_encrypt_loop, loopargs);
2095 print_result(D_EDE3_DES, testnum, count, d);
2100 if (doit[D_CBC_128_AES]) {
2101 for (testnum = 0; testnum < size_num; testnum++) {
2102 print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][testnum],
2103 lengths[testnum], seconds.sym);
2106 run_benchmark(async_jobs, AES_cbc_128_encrypt_loop, loopargs);
2108 print_result(D_CBC_128_AES, testnum, count, d);
2111 if (doit[D_CBC_192_AES]) {
2112 for (testnum = 0; testnum < size_num; testnum++) {
2113 print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][testnum],
2114 lengths[testnum], seconds.sym);
2117 run_benchmark(async_jobs, AES_cbc_192_encrypt_loop, loopargs);
2119 print_result(D_CBC_192_AES, testnum, count, d);
2122 if (doit[D_CBC_256_AES]) {
2123 for (testnum = 0; testnum < size_num; testnum++) {
2124 print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][testnum],
2125 lengths[testnum], seconds.sym);
2128 run_benchmark(async_jobs, AES_cbc_256_encrypt_loop, loopargs);
2130 print_result(D_CBC_256_AES, testnum, count, d);
2134 if (doit[D_IGE_128_AES]) {
2135 for (testnum = 0; testnum < size_num; testnum++) {
2136 print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][testnum],
2137 lengths[testnum], seconds.sym);
2140 run_benchmark(async_jobs, AES_ige_128_encrypt_loop, loopargs);
2142 print_result(D_IGE_128_AES, testnum, count, d);
2145 if (doit[D_IGE_192_AES]) {
2146 for (testnum = 0; testnum < size_num; testnum++) {
2147 print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][testnum],
2148 lengths[testnum], seconds.sym);
2151 run_benchmark(async_jobs, AES_ige_192_encrypt_loop, loopargs);
2153 print_result(D_IGE_192_AES, testnum, count, d);
2156 if (doit[D_IGE_256_AES]) {
2157 for (testnum = 0; testnum < size_num; testnum++) {
2158 print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][testnum],
2159 lengths[testnum], seconds.sym);
2162 run_benchmark(async_jobs, AES_ige_256_encrypt_loop, loopargs);
2164 print_result(D_IGE_256_AES, testnum, count, d);
2167 if (doit[D_GHASH]) {
2168 for (i = 0; i < loopargs_len; i++) {
2169 loopargs[i].gcm_ctx =
2170 CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
2171 CRYPTO_gcm128_setiv(loopargs[i].gcm_ctx,
2172 (unsigned char *)"0123456789ab", 12);
2175 for (testnum = 0; testnum < size_num; testnum++) {
2176 print_message(names[D_GHASH], c[D_GHASH][testnum],
2177 lengths[testnum], seconds.sym);
2179 count = run_benchmark(async_jobs, CRYPTO_gcm128_aad_loop, loopargs);
2181 print_result(D_GHASH, testnum, count, d);
2183 for (i = 0; i < loopargs_len; i++)
2184 CRYPTO_gcm128_release(loopargs[i].gcm_ctx);
2186 #ifndef OPENSSL_NO_CAMELLIA
2187 if (doit[D_CBC_128_CML]) {
2188 if (async_jobs > 0) {
2189 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2190 names[D_CBC_128_CML]);
2191 doit[D_CBC_128_CML] = 0;
2193 for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2194 print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][testnum],
2195 lengths[testnum], seconds.sym);
2197 for (count = 0, run = 1; COND(c[D_CBC_128_CML][testnum]); count++)
2198 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2199 (size_t)lengths[testnum], &camellia_ks1,
2200 iv, CAMELLIA_ENCRYPT);
2202 print_result(D_CBC_128_CML, testnum, count, d);
2205 if (doit[D_CBC_192_CML]) {
2206 if (async_jobs > 0) {
2207 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2208 names[D_CBC_192_CML]);
2209 doit[D_CBC_192_CML] = 0;
2211 for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2212 print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][testnum],
2213 lengths[testnum], seconds.sym);
2214 if (async_jobs > 0) {
2215 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2219 for (count = 0, run = 1; COND(c[D_CBC_192_CML][testnum]); count++)
2220 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2221 (size_t)lengths[testnum], &camellia_ks2,
2222 iv, CAMELLIA_ENCRYPT);
2224 print_result(D_CBC_192_CML, testnum, count, d);
2227 if (doit[D_CBC_256_CML]) {
2228 if (async_jobs > 0) {
2229 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2230 names[D_CBC_256_CML]);
2231 doit[D_CBC_256_CML] = 0;
2233 for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2234 print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][testnum],
2235 lengths[testnum], seconds.sym);
2237 for (count = 0, run = 1; COND(c[D_CBC_256_CML][testnum]); count++)
2238 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2239 (size_t)lengths[testnum], &camellia_ks3,
2240 iv, CAMELLIA_ENCRYPT);
2242 print_result(D_CBC_256_CML, testnum, count, d);
2246 #ifndef OPENSSL_NO_IDEA
2247 if (doit[D_CBC_IDEA]) {
2248 if (async_jobs > 0) {
2249 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2251 doit[D_CBC_IDEA] = 0;
2253 for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2254 print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][testnum],
2255 lengths[testnum], seconds.sym);
2257 for (count = 0, run = 1; COND(c[D_CBC_IDEA][testnum]); count++)
2258 IDEA_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2259 (size_t)lengths[testnum], &idea_ks,
2262 print_result(D_CBC_IDEA, testnum, count, d);
2266 #ifndef OPENSSL_NO_SEED
2267 if (doit[D_CBC_SEED]) {
2268 if (async_jobs > 0) {
2269 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2271 doit[D_CBC_SEED] = 0;
2273 for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2274 print_message(names[D_CBC_SEED], c[D_CBC_SEED][testnum],
2275 lengths[testnum], seconds.sym);
2277 for (count = 0, run = 1; COND(c[D_CBC_SEED][testnum]); count++)
2278 SEED_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2279 (size_t)lengths[testnum], &seed_ks, iv, 1);
2281 print_result(D_CBC_SEED, testnum, count, d);
2285 #ifndef OPENSSL_NO_RC2
2286 if (doit[D_CBC_RC2]) {
2287 if (async_jobs > 0) {
2288 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2290 doit[D_CBC_RC2] = 0;
2292 for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2293 print_message(names[D_CBC_RC2], c[D_CBC_RC2][testnum],
2294 lengths[testnum], seconds.sym);
2295 if (async_jobs > 0) {
2296 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2300 for (count = 0, run = 1; COND(c[D_CBC_RC2][testnum]); count++)
2301 RC2_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2302 (size_t)lengths[testnum], &rc2_ks,
2305 print_result(D_CBC_RC2, testnum, count, d);
2309 #ifndef OPENSSL_NO_RC5
2310 if (doit[D_CBC_RC5]) {
2311 if (async_jobs > 0) {
2312 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2314 doit[D_CBC_RC5] = 0;
2316 for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2317 print_message(names[D_CBC_RC5], c[D_CBC_RC5][testnum],
2318 lengths[testnum], seconds.sym);
2319 if (async_jobs > 0) {
2320 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2324 for (count = 0, run = 1; COND(c[D_CBC_RC5][testnum]); count++)
2325 RC5_32_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2326 (size_t)lengths[testnum], &rc5_ks,
2329 print_result(D_CBC_RC5, testnum, count, d);
2333 #ifndef OPENSSL_NO_BF
2334 if (doit[D_CBC_BF]) {
2335 if (async_jobs > 0) {
2336 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2340 for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2341 print_message(names[D_CBC_BF], c[D_CBC_BF][testnum],
2342 lengths[testnum], seconds.sym);
2344 for (count = 0, run = 1; COND(c[D_CBC_BF][testnum]); count++)
2345 BF_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2346 (size_t)lengths[testnum], &bf_ks,
2349 print_result(D_CBC_BF, testnum, count, d);
2353 #ifndef OPENSSL_NO_CAST
2354 if (doit[D_CBC_CAST]) {
2355 if (async_jobs > 0) {
2356 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2358 doit[D_CBC_CAST] = 0;
2360 for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2361 print_message(names[D_CBC_CAST], c[D_CBC_CAST][testnum],
2362 lengths[testnum], seconds.sym);
2364 for (count = 0, run = 1; COND(c[D_CBC_CAST][testnum]); count++)
2365 CAST_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2366 (size_t)lengths[testnum], &cast_ks,
2369 print_result(D_CBC_CAST, testnum, count, d);
2374 for (testnum = 0; testnum < size_num; testnum++) {
2375 print_message(names[D_RAND], c[D_RAND][testnum], lengths[testnum],
2378 count = run_benchmark(async_jobs, RAND_bytes_loop, loopargs);
2380 print_result(D_RAND, testnum, count, d);
2385 if (multiblock && evp_cipher) {
2387 (EVP_CIPHER_flags(evp_cipher) &
2388 EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
2389 BIO_printf(bio_err, "%s is not multi-block capable\n",
2390 OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
2393 if (async_jobs > 0) {
2394 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2397 multiblock_speed(evp_cipher, &seconds);
2401 for (testnum = 0; testnum < size_num; testnum++) {
2404 names[D_EVP] = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
2406 * -O3 -fschedule-insns messes up an optimization here!
2407 * names[D_EVP] somehow becomes NULL
2409 print_message(names[D_EVP], save_count, lengths[testnum],
2412 for (k = 0; k < loopargs_len; k++) {
2413 loopargs[k].ctx = EVP_CIPHER_CTX_new();
2414 EVP_CipherInit_ex(loopargs[k].ctx, evp_cipher, NULL, NULL,
2415 iv, decrypt ? 0 : 1);
2417 EVP_CIPHER_CTX_set_padding(loopargs[k].ctx, 0);
2419 keylen = EVP_CIPHER_CTX_key_length(loopargs[k].ctx);
2420 loopargs[k].key = app_malloc(keylen, "evp_cipher key");
2421 EVP_CIPHER_CTX_rand_key(loopargs[k].ctx, loopargs[k].key);
2422 EVP_CipherInit_ex(loopargs[k].ctx, NULL, NULL,
2423 loopargs[k].key, NULL, -1);
2424 OPENSSL_clear_free(loopargs[k].key, keylen);
2426 switch (EVP_CIPHER_mode(evp_cipher)) {
2427 case EVP_CIPH_CCM_MODE:
2428 loopfunc = EVP_Update_loop_ccm;
2431 loopfunc = EVP_Update_loop;
2435 count = run_benchmark(async_jobs, loopfunc, loopargs);
2437 for (k = 0; k < loopargs_len; k++) {
2438 EVP_CIPHER_CTX_free(loopargs[k].ctx);
2442 names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
2443 print_message(names[D_EVP], save_count, lengths[testnum],
2446 count = run_benchmark(async_jobs, EVP_Digest_loop, loopargs);
2449 print_result(D_EVP, testnum, count, d);
2453 for (i = 0; i < loopargs_len; i++)
2454 RAND_bytes(loopargs[i].buf, 36);
2456 #ifndef OPENSSL_NO_RSA
2457 for (testnum = 0; testnum < RSA_NUM; testnum++) {
2459 if (!rsa_doit[testnum])
2461 for (i = 0; i < loopargs_len; i++) {
2463 /* we haven't set keys yet, generate multi-prime RSA keys */
2464 BIGNUM *bn = BN_new();
2468 if (!BN_set_word(bn, RSA_F4)) {
2473 BIO_printf(bio_err, "Generate multi-prime RSA key for %s\n",
2474 rsa_choices[testnum].name);
2476 loopargs[i].rsa_key[testnum] = RSA_new();
2477 if (loopargs[i].rsa_key[testnum] == NULL) {
2482 if (!RSA_generate_multi_prime_key(loopargs[i].rsa_key[testnum],
2484 primes, bn, NULL)) {
2490 st = RSA_sign(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2491 &loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2497 "RSA sign failure. No RSA sign will be done.\n");
2498 ERR_print_errors(bio_err);
2501 pkey_print_message("private", "rsa",
2502 rsa_c[testnum][0], rsa_bits[testnum],
2504 /* RSA_blinding_on(rsa_key[testnum],NULL); */
2506 count = run_benchmark(async_jobs, RSA_sign_loop, loopargs);
2509 mr ? "+R1:%ld:%d:%.2f\n"
2510 : "%ld %d bit private RSA's in %.2fs\n",
2511 count, rsa_bits[testnum], d);
2512 rsa_results[testnum][0] = (double)count / d;
2516 for (i = 0; i < loopargs_len; i++) {
2517 st = RSA_verify(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2518 loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2524 "RSA verify failure. No RSA verify will be done.\n");
2525 ERR_print_errors(bio_err);
2526 rsa_doit[testnum] = 0;
2528 pkey_print_message("public", "rsa",
2529 rsa_c[testnum][1], rsa_bits[testnum],
2532 count = run_benchmark(async_jobs, RSA_verify_loop, loopargs);
2535 mr ? "+R2:%ld:%d:%.2f\n"
2536 : "%ld %d bit public RSA's in %.2fs\n",
2537 count, rsa_bits[testnum], d);
2538 rsa_results[testnum][1] = (double)count / d;
2541 if (rsa_count <= 1) {
2542 /* if longer than 10s, don't do any more */
2543 for (testnum++; testnum < RSA_NUM; testnum++)
2544 rsa_doit[testnum] = 0;
2547 #endif /* OPENSSL_NO_RSA */
2549 for (i = 0; i < loopargs_len; i++)
2550 RAND_bytes(loopargs[i].buf, 36);
2552 #ifndef OPENSSL_NO_DSA
2553 for (testnum = 0; testnum < DSA_NUM; testnum++) {
2555 if (!dsa_doit[testnum])
2558 /* DSA_generate_key(dsa_key[testnum]); */
2559 /* DSA_sign_setup(dsa_key[testnum],NULL); */
2560 for (i = 0; i < loopargs_len; i++) {
2561 st = DSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2562 &loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2568 "DSA sign failure. No DSA sign will be done.\n");
2569 ERR_print_errors(bio_err);
2572 pkey_print_message("sign", "dsa",
2573 dsa_c[testnum][0], dsa_bits[testnum],
2576 count = run_benchmark(async_jobs, DSA_sign_loop, loopargs);
2579 mr ? "+R3:%ld:%d:%.2f\n"
2580 : "%ld %d bit DSA signs in %.2fs\n",
2581 count, dsa_bits[testnum], d);
2582 dsa_results[testnum][0] = (double)count / d;
2586 for (i = 0; i < loopargs_len; i++) {
2587 st = DSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2588 loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2594 "DSA verify failure. No DSA verify will be done.\n");
2595 ERR_print_errors(bio_err);
2596 dsa_doit[testnum] = 0;
2598 pkey_print_message("verify", "dsa",
2599 dsa_c[testnum][1], dsa_bits[testnum],
2602 count = run_benchmark(async_jobs, DSA_verify_loop, loopargs);
2605 mr ? "+R4:%ld:%d:%.2f\n"
2606 : "%ld %d bit DSA verify in %.2fs\n",
2607 count, dsa_bits[testnum], d);
2608 dsa_results[testnum][1] = (double)count / d;
2611 if (rsa_count <= 1) {
2612 /* if longer than 10s, don't do any more */
2613 for (testnum++; testnum < DSA_NUM; testnum++)
2614 dsa_doit[testnum] = 0;
2617 #endif /* OPENSSL_NO_DSA */
2619 #ifndef OPENSSL_NO_EC
2620 for (testnum = 0; testnum < EC_NUM; testnum++) {
2623 if (!ecdsa_doit[testnum])
2624 continue; /* Ignore Curve */
2625 for (i = 0; i < loopargs_len; i++) {
2626 loopargs[i].ecdsa[testnum] =
2627 EC_KEY_new_by_curve_name(test_curves[testnum]);
2628 if (loopargs[i].ecdsa[testnum] == NULL) {
2634 BIO_printf(bio_err, "ECDSA failure.\n");
2635 ERR_print_errors(bio_err);
2638 for (i = 0; i < loopargs_len; i++) {
2639 EC_KEY_precompute_mult(loopargs[i].ecdsa[testnum], NULL);
2640 /* Perform ECDSA signature test */
2641 EC_KEY_generate_key(loopargs[i].ecdsa[testnum]);
2642 st = ECDSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2643 &loopargs[i].siglen,
2644 loopargs[i].ecdsa[testnum]);
2650 "ECDSA sign failure. No ECDSA sign will be done.\n");
2651 ERR_print_errors(bio_err);
2654 pkey_print_message("sign", "ecdsa",
2655 ecdsa_c[testnum][0],
2656 test_curves_bits[testnum],
2659 count = run_benchmark(async_jobs, ECDSA_sign_loop, loopargs);
2663 mr ? "+R5:%ld:%d:%.2f\n" :
2664 "%ld %d bit ECDSA signs in %.2fs \n",
2665 count, test_curves_bits[testnum], d);
2666 ecdsa_results[testnum][0] = (double)count / d;
2670 /* Perform ECDSA verification test */
2671 for (i = 0; i < loopargs_len; i++) {
2672 st = ECDSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2674 loopargs[i].ecdsa[testnum]);
2680 "ECDSA verify failure. No ECDSA verify will be done.\n");
2681 ERR_print_errors(bio_err);
2682 ecdsa_doit[testnum] = 0;
2684 pkey_print_message("verify", "ecdsa",
2685 ecdsa_c[testnum][1],
2686 test_curves_bits[testnum],
2689 count = run_benchmark(async_jobs, ECDSA_verify_loop, loopargs);
2692 mr ? "+R6:%ld:%d:%.2f\n"
2693 : "%ld %d bit ECDSA verify in %.2fs\n",
2694 count, test_curves_bits[testnum], d);
2695 ecdsa_results[testnum][1] = (double)count / d;
2698 if (rsa_count <= 1) {
2699 /* if longer than 10s, don't do any more */
2700 for (testnum++; testnum < EC_NUM; testnum++)
2701 ecdsa_doit[testnum] = 0;
2706 for (testnum = 0; testnum < EC_NUM; testnum++) {
2707 int ecdh_checks = 1;
2709 if (!ecdh_doit[testnum])
2712 for (i = 0; i < loopargs_len; i++) {
2713 EVP_PKEY_CTX *kctx = NULL;
2714 EVP_PKEY_CTX *test_ctx = NULL;
2715 EVP_PKEY_CTX *ctx = NULL;
2716 EVP_PKEY *key_A = NULL;
2717 EVP_PKEY *key_B = NULL;
2721 /* Ensure that the error queue is empty */
2722 if (ERR_peek_error()) {
2724 "WARNING: the error queue contains previous unhandled errors.\n");
2725 ERR_print_errors(bio_err);
2728 /* Let's try to create a ctx directly from the NID: this works for
2729 * curves like Curve25519 that are not implemented through the low
2730 * level EC interface.
2731 * If this fails we try creating a EVP_PKEY_EC generic param ctx,
2732 * then we set the curve by NID before deriving the actual keygen
2733 * ctx for that specific curve. */
2734 kctx = EVP_PKEY_CTX_new_id(test_curves[testnum], NULL); /* keygen ctx from NID */
2736 EVP_PKEY_CTX *pctx = NULL;
2737 EVP_PKEY *params = NULL;
2739 /* If we reach this code EVP_PKEY_CTX_new_id() failed and a
2740 * "int_ctx_new:unsupported algorithm" error was added to the
2742 * We remove it from the error queue as we are handling it. */
2743 unsigned long error = ERR_peek_error(); /* peek the latest error in the queue */
2744 if (error == ERR_peek_last_error() && /* oldest and latest errors match */
2745 /* check that the error origin matches */
2746 ERR_GET_LIB(error) == ERR_LIB_EVP &&
2747 ERR_GET_FUNC(error) == EVP_F_INT_CTX_NEW &&
2748 ERR_GET_REASON(error) == EVP_R_UNSUPPORTED_ALGORITHM)
2749 ERR_get_error(); /* pop error from queue */
2750 if (ERR_peek_error()) {
2752 "Unhandled error in the error queue during ECDH init.\n");
2753 ERR_print_errors(bio_err);
2758 if ( /* Create the context for parameter generation */
2759 !(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL)) ||
2760 /* Initialise the parameter generation */
2761 !EVP_PKEY_paramgen_init(pctx) ||
2762 /* Set the curve by NID */
2763 !EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx,
2766 /* Create the parameter object params */
2767 !EVP_PKEY_paramgen(pctx, ¶ms)) {
2769 BIO_printf(bio_err, "ECDH EC params init failure.\n");
2770 ERR_print_errors(bio_err);
2774 /* Create the context for the key generation */
2775 kctx = EVP_PKEY_CTX_new(params, NULL);
2777 EVP_PKEY_free(params);
2779 EVP_PKEY_CTX_free(pctx);
2782 if (kctx == NULL || /* keygen ctx is not null */
2783 !EVP_PKEY_keygen_init(kctx) /* init keygen ctx */ ) {
2785 BIO_printf(bio_err, "ECDH keygen failure.\n");
2786 ERR_print_errors(bio_err);
2791 if (!EVP_PKEY_keygen(kctx, &key_A) || /* generate secret key A */
2792 !EVP_PKEY_keygen(kctx, &key_B) || /* generate secret key B */
2793 !(ctx = EVP_PKEY_CTX_new(key_A, NULL)) || /* derivation ctx from skeyA */
2794 !EVP_PKEY_derive_init(ctx) || /* init derivation ctx */
2795 !EVP_PKEY_derive_set_peer(ctx, key_B) || /* set peer pubkey in ctx */
2796 !EVP_PKEY_derive(ctx, NULL, &outlen) || /* determine max length */
2797 outlen == 0 || /* ensure outlen is a valid size */
2798 outlen > MAX_ECDH_SIZE /* avoid buffer overflow */ ) {
2800 BIO_printf(bio_err, "ECDH key generation failure.\n");
2801 ERR_print_errors(bio_err);
2806 /* Here we perform a test run, comparing the output of a*B and b*A;
2807 * we try this here and assume that further EVP_PKEY_derive calls
2808 * never fail, so we can skip checks in the actually benchmarked
2809 * code, for maximum performance. */
2810 if (!(test_ctx = EVP_PKEY_CTX_new(key_B, NULL)) || /* test ctx from skeyB */
2811 !EVP_PKEY_derive_init(test_ctx) || /* init derivation test_ctx */
2812 !EVP_PKEY_derive_set_peer(test_ctx, key_A) || /* set peer pubkey in test_ctx */
2813 !EVP_PKEY_derive(test_ctx, NULL, &test_outlen) || /* determine max length */
2814 !EVP_PKEY_derive(ctx, loopargs[i].secret_a, &outlen) || /* compute a*B */
2815 !EVP_PKEY_derive(test_ctx, loopargs[i].secret_b, &test_outlen) || /* compute b*A */
2816 test_outlen != outlen /* compare output length */ ) {
2818 BIO_printf(bio_err, "ECDH computation failure.\n");
2819 ERR_print_errors(bio_err);
2824 /* Compare the computation results: CRYPTO_memcmp() returns 0 if equal */
2825 if (CRYPTO_memcmp(loopargs[i].secret_a,
2826 loopargs[i].secret_b, outlen)) {
2828 BIO_printf(bio_err, "ECDH computations don't match.\n");
2829 ERR_print_errors(bio_err);
2834 loopargs[i].ecdh_ctx[testnum] = ctx;
2835 loopargs[i].outlen[testnum] = outlen;
2837 EVP_PKEY_free(key_A);
2838 EVP_PKEY_free(key_B);
2839 EVP_PKEY_CTX_free(kctx);
2841 EVP_PKEY_CTX_free(test_ctx);
2844 if (ecdh_checks != 0) {
2845 pkey_print_message("", "ecdh",
2847 test_curves_bits[testnum],
2851 run_benchmark(async_jobs, ECDH_EVP_derive_key_loop, loopargs);
2854 mr ? "+R7:%ld:%d:%.2f\n" :
2855 "%ld %d-bit ECDH ops in %.2fs\n", count,
2856 test_curves_bits[testnum], d);
2857 ecdh_results[testnum][0] = (double)count / d;
2861 if (rsa_count <= 1) {
2862 /* if longer than 10s, don't do any more */
2863 for (testnum++; testnum < EC_NUM; testnum++)
2864 ecdh_doit[testnum] = 0;
2867 #endif /* OPENSSL_NO_EC */
2872 printf("%s\n", OpenSSL_version(OPENSSL_VERSION));
2873 printf("%s\n", OpenSSL_version(OPENSSL_BUILT_ON));
2875 printf("%s ", BN_options());
2876 #ifndef OPENSSL_NO_MD2
2877 printf("%s ", MD2_options());
2879 #ifndef OPENSSL_NO_RC4
2880 printf("%s ", RC4_options());
2882 #ifndef OPENSSL_NO_DES
2883 printf("%s ", DES_options());
2885 printf("%s ", AES_options());
2886 #ifndef OPENSSL_NO_IDEA
2887 printf("%s ", IDEA_options());
2889 #ifndef OPENSSL_NO_BF
2890 printf("%s ", BF_options());
2892 printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
2900 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2903 for (testnum = 0; testnum < size_num; testnum++)
2904 printf(mr ? ":%d" : "%7d bytes", lengths[testnum]);
2908 for (k = 0; k < ALGOR_NUM; k++) {
2912 printf("+F:%d:%s", k, names[k]);
2914 printf("%-13s", names[k]);
2915 for (testnum = 0; testnum < size_num; testnum++) {
2916 if (results[k][testnum] > 10000 && !mr)
2917 printf(" %11.2fk", results[k][testnum] / 1e3);
2919 printf(mr ? ":%.2f" : " %11.2f ", results[k][testnum]);
2923 #ifndef OPENSSL_NO_RSA
2925 for (k = 0; k < RSA_NUM; k++) {
2928 if (testnum && !mr) {
2929 printf("%18ssign verify sign/s verify/s\n", " ");
2933 printf("+F2:%u:%u:%f:%f\n",
2934 k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2936 printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2937 rsa_bits[k], 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1],
2938 rsa_results[k][0], rsa_results[k][1]);
2941 #ifndef OPENSSL_NO_DSA
2943 for (k = 0; k < DSA_NUM; k++) {
2946 if (testnum && !mr) {
2947 printf("%18ssign verify sign/s verify/s\n", " ");
2951 printf("+F3:%u:%u:%f:%f\n",
2952 k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2954 printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2955 dsa_bits[k], 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1],
2956 dsa_results[k][0], dsa_results[k][1]);
2959 #ifndef OPENSSL_NO_EC
2961 for (k = 0; k < EC_NUM; k++) {
2964 if (testnum && !mr) {
2965 printf("%30ssign verify sign/s verify/s\n", " ");
2970 printf("+F4:%u:%u:%f:%f\n",
2971 k, test_curves_bits[k],
2972 ecdsa_results[k][0], ecdsa_results[k][1]);
2974 printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2975 test_curves_bits[k],
2976 test_curves_names[k],
2977 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1],
2978 ecdsa_results[k][0], ecdsa_results[k][1]);
2982 for (k = 0; k < EC_NUM; k++) {
2985 if (testnum && !mr) {
2986 printf("%30sop op/s\n", " ");
2990 printf("+F5:%u:%u:%f:%f\n",
2991 k, test_curves_bits[k],
2992 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2995 printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2996 test_curves_bits[k],
2997 test_curves_names[k],
2998 1.0 / ecdh_results[k][0], ecdh_results[k][0]);
3005 ERR_print_errors(bio_err);
3006 for (i = 0; i < loopargs_len; i++) {
3007 OPENSSL_free(loopargs[i].buf_malloc);
3008 OPENSSL_free(loopargs[i].buf2_malloc);
3010 #ifndef OPENSSL_NO_RSA
3011 for (k = 0; k < RSA_NUM; k++)
3012 RSA_free(loopargs[i].rsa_key[k]);
3014 #ifndef OPENSSL_NO_DSA
3015 for (k = 0; k < DSA_NUM; k++)
3016 DSA_free(loopargs[i].dsa_key[k]);
3018 #ifndef OPENSSL_NO_EC
3019 for (k = 0; k < EC_NUM; k++) {
3020 EC_KEY_free(loopargs[i].ecdsa[k]);
3021 EVP_PKEY_CTX_free(loopargs[i].ecdh_ctx[k]);
3023 OPENSSL_free(loopargs[i].secret_a);
3024 OPENSSL_free(loopargs[i].secret_b);
3028 if (async_jobs > 0) {
3029 for (i = 0; i < loopargs_len; i++)
3030 ASYNC_WAIT_CTX_free(loopargs[i].wait_ctx);
3034 ASYNC_cleanup_thread();
3036 OPENSSL_free(loopargs);
3041 static void print_message(const char *s, long num, int length, int tm)
3045 mr ? "+DT:%s:%d:%d\n"
3046 : "Doing %s for %ds on %d size blocks: ", s, tm, length);
3047 (void)BIO_flush(bio_err);
3051 mr ? "+DN:%s:%ld:%d\n"
3052 : "Doing %s %ld times on %d size blocks: ", s, num, length);
3053 (void)BIO_flush(bio_err);
3057 static void pkey_print_message(const char *str, const char *str2, long num,
3062 mr ? "+DTP:%d:%s:%s:%d\n"
3063 : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
3064 (void)BIO_flush(bio_err);
3068 mr ? "+DNP:%ld:%d:%s:%s\n"
3069 : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
3070 (void)BIO_flush(bio_err);
3074 static void print_result(int alg, int run_no, int count, double time_used)
3077 BIO_puts(bio_err, "EVP error!\n");
3081 mr ? "+R:%d:%s:%f\n"
3082 : "%d %s's in %.2fs\n", count, names[alg], time_used);
3083 results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
3087 static char *sstrsep(char **string, const char *delim)
3090 char *token = *string;
3095 memset(isdelim, 0, sizeof(isdelim));
3099 isdelim[(unsigned char)(*delim)] = 1;
3103 while (!isdelim[(unsigned char)(**string)]) {
3115 static int do_multi(int multi, int size_num)
3120 static char sep[] = ":";
3122 fds = malloc(sizeof(*fds) * multi);
3123 for (n = 0; n < multi; ++n) {
3124 if (pipe(fd) == -1) {
3125 BIO_printf(bio_err, "pipe failure\n");
3129 (void)BIO_flush(bio_err);
3136 if (dup(fd[1]) == -1) {
3137 BIO_printf(bio_err, "dup failed\n");
3146 printf("Forked child %d\n", n);
3149 /* for now, assume the pipe is long enough to take all the output */
3150 for (n = 0; n < multi; ++n) {
3155 f = fdopen(fds[n], "r");
3156 while (fgets(buf, sizeof(buf), f)) {
3157 p = strchr(buf, '\n');
3160 if (buf[0] != '+') {
3162 "Don't understand line '%s' from child %d\n", buf,
3166 printf("Got: %s from %d\n", buf, n);
3167 if (strncmp(buf, "+F:", 3) == 0) {
3172 alg = atoi(sstrsep(&p, sep));
3174 for (j = 0; j < size_num; ++j)
3175 results[alg][j] += atof(sstrsep(&p, sep));
3176 } else if (strncmp(buf, "+F2:", 4) == 0) {
3181 k = atoi(sstrsep(&p, sep));
3184 d = atof(sstrsep(&p, sep));
3185 rsa_results[k][0] += d;
3187 d = atof(sstrsep(&p, sep));
3188 rsa_results[k][1] += d;
3190 # ifndef OPENSSL_NO_DSA
3191 else if (strncmp(buf, "+F3:", 4) == 0) {
3196 k = atoi(sstrsep(&p, sep));
3199 d = atof(sstrsep(&p, sep));
3200 dsa_results[k][0] += d;
3202 d = atof(sstrsep(&p, sep));
3203 dsa_results[k][1] += d;
3206 # ifndef OPENSSL_NO_EC
3207 else if (strncmp(buf, "+F4:", 4) == 0) {
3212 k = atoi(sstrsep(&p, sep));
3215 d = atof(sstrsep(&p, sep));
3216 ecdsa_results[k][0] += d;
3218 d = atof(sstrsep(&p, sep));
3219 ecdsa_results[k][1] += d;
3220 } else if (strncmp(buf, "+F5:", 4) == 0) {
3225 k = atoi(sstrsep(&p, sep));
3228 d = atof(sstrsep(&p, sep));
3229 ecdh_results[k][0] += d;
3233 else if (strncmp(buf, "+H:", 3) == 0) {
3236 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf,
3247 static void multiblock_speed(const EVP_CIPHER *evp_cipher,
3248 const openssl_speed_sec_t *seconds)
3250 static const int mblengths_list[] =
3251 { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
3252 const int *mblengths = mblengths_list;
3253 int j, count, keylen, num = OSSL_NELEM(mblengths_list);
3254 const char *alg_name;
3255 unsigned char *inp, *out, *key, no_key[32], no_iv[16];
3256 EVP_CIPHER_CTX *ctx;
3259 if (lengths_single) {
3260 mblengths = &lengths_single;
3264 inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
3265 out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
3266 ctx = EVP_CIPHER_CTX_new();
3267 EVP_EncryptInit_ex(ctx, evp_cipher, NULL, NULL, no_iv);
3269 keylen = EVP_CIPHER_CTX_key_length(ctx);
3270 key = app_malloc(keylen, "evp_cipher key");
3271 EVP_CIPHER_CTX_rand_key(ctx, key);
3272 EVP_EncryptInit_ex(ctx, NULL, NULL, key, NULL);
3273 OPENSSL_clear_free(key, keylen);
3275 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key), no_key);
3276 alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
3278 for (j = 0; j < num; j++) {
3279 print_message(alg_name, 0, mblengths[j], seconds->sym);
3281 for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
3282 unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
3283 EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
3284 size_t len = mblengths[j];
3287 memset(aad, 0, 8); /* avoid uninitialized values */
3288 aad[8] = 23; /* SSL3_RT_APPLICATION_DATA */
3289 aad[9] = 3; /* version */
3291 aad[11] = 0; /* length */
3293 mb_param.out = NULL;
3296 mb_param.interleave = 8;
3298 packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
3299 sizeof(mb_param), &mb_param);
3305 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
3306 sizeof(mb_param), &mb_param);
3310 RAND_bytes(out, 16);
3312 aad[11] = (unsigned char)(len >> 8);
3313 aad[12] = (unsigned char)(len);
3314 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
3315 EVP_AEAD_TLS1_AAD_LEN, aad);
3316 EVP_Cipher(ctx, out, inp, len + pad);
3320 BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
3321 : "%d %s's in %.2fs\n", count, "evp", d);
3322 results[D_EVP][j] = ((double)count) / d * mblengths[j];
3326 fprintf(stdout, "+H");
3327 for (j = 0; j < num; j++)
3328 fprintf(stdout, ":%d", mblengths[j]);
3329 fprintf(stdout, "\n");
3330 fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
3331 for (j = 0; j < num; j++)
3332 fprintf(stdout, ":%.2f", results[D_EVP][j]);
3333 fprintf(stdout, "\n");
3336 "The 'numbers' are in 1000s of bytes per second processed.\n");
3337 fprintf(stdout, "type ");
3338 for (j = 0; j < num; j++)
3339 fprintf(stdout, "%7d bytes", mblengths[j]);
3340 fprintf(stdout, "\n");
3341 fprintf(stdout, "%-24s", alg_name);
3343 for (j = 0; j < num; j++) {
3344 if (results[D_EVP][j] > 10000)
3345 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
3347 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
3349 fprintf(stdout, "\n");
3354 EVP_CIPHER_CTX_free(ctx);