2 * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
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
10 /* ====================================================================
11 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
13 * Portions of the attached software ("Contribution") are developed by
14 * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
16 * The Contribution is licensed pursuant to the OpenSSL open source
17 * license provided above.
19 * The ECDH and ECDSA speed test software is originally written by
20 * Sumit Gupta of Sun Microsystems Laboratories.
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
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
51 #include <openssl/bn.h>
52 #ifndef OPENSSL_NO_DES
53 # include <openssl/des.h>
55 #include <openssl/aes.h>
56 #ifndef OPENSSL_NO_CAMELLIA
57 # include <openssl/camellia.h>
59 #ifndef OPENSSL_NO_MD2
60 # include <openssl/md2.h>
62 #ifndef OPENSSL_NO_MDC2
63 # include <openssl/mdc2.h>
65 #ifndef OPENSSL_NO_MD4
66 # include <openssl/md4.h>
68 #ifndef OPENSSL_NO_MD5
69 # include <openssl/md5.h>
71 #include <openssl/hmac.h>
72 #include <openssl/sha.h>
73 #ifndef OPENSSL_NO_RMD160
74 # include <openssl/ripemd.h>
76 #ifndef OPENSSL_NO_WHIRLPOOL
77 # include <openssl/whrlpool.h>
79 #ifndef OPENSSL_NO_RC4
80 # include <openssl/rc4.h>
82 #ifndef OPENSSL_NO_RC5
83 # include <openssl/rc5.h>
85 #ifndef OPENSSL_NO_RC2
86 # include <openssl/rc2.h>
88 #ifndef OPENSSL_NO_IDEA
89 # include <openssl/idea.h>
91 #ifndef OPENSSL_NO_SEED
92 # include <openssl/seed.h>
95 # include <openssl/blowfish.h>
97 #ifndef OPENSSL_NO_CAST
98 # include <openssl/cast.h>
100 #ifndef OPENSSL_NO_RSA
101 # include <openssl/rsa.h>
102 # include "./testrsa.h"
104 #include <openssl/x509.h>
105 #ifndef OPENSSL_NO_DSA
106 # include <openssl/dsa.h>
107 # include "./testdsa.h"
109 #ifndef OPENSSL_NO_EC
110 # include <openssl/ec.h>
112 #include <openssl/modes.h>
115 # if defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_WINDOWS)
129 #define BUFSIZE (1024*16+1)
130 #define MAX_MISALIGNMENT 63
139 #define MAX_ECDH_SIZE 256
142 static volatile int run = 0;
145 static int usertime = 1;
147 typedef void *(*kdf_fn) (
148 const void *in, size_t inlen, void *out, size_t *xoutlen);
150 typedef struct loopargs_st {
151 ASYNC_JOB *inprogress_job;
152 ASYNC_WAIT_CTX *wait_ctx;
155 unsigned char *buf_malloc;
156 unsigned char *buf2_malloc;
158 #ifndef OPENSSL_NO_RSA
159 RSA *rsa_key[RSA_NUM];
161 #ifndef OPENSSL_NO_DSA
162 DSA *dsa_key[DSA_NUM];
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;
175 GCM128_CONTEXT *gcm_ctx;
178 #ifndef OPENSSL_NO_MD2
179 static int EVP_Digest_MD2_loop(void *args);
182 #ifndef OPENSSL_NO_MDC2
183 static int EVP_Digest_MDC2_loop(void *args);
185 #ifndef OPENSSL_NO_MD4
186 static int EVP_Digest_MD4_loop(void *args);
188 #ifndef OPENSSL_NO_MD5
189 static int MD5_loop(void *args);
190 static int HMAC_loop(void *args);
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);
198 #ifndef OPENSSL_NO_RMD160
199 static int EVP_Digest_RMD160_loop(void *args);
201 #ifndef OPENSSL_NO_RC4
202 static int RC4_loop(void *args);
204 #ifndef OPENSSL_NO_DES
205 static int DES_ncbc_encrypt_loop(void *args);
206 static int DES_ede3_cbc_encrypt_loop(void *args);
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);
221 #ifndef OPENSSL_NO_DSA
222 static int DSA_sign_loop(void *args);
223 static int DSA_verify_loop(void *args);
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);
230 static int run_benchmark(int async_jobs, int (*loop_function)(void *), loopargs_t *loopargs);
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);
238 static int do_multi(int multi);
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"
251 static double results[ALGOR_NUM][SIZE_NUM];
253 static const int lengths[SIZE_NUM] = {
254 16, 64, 256, 1024, 8 * 1024, 16 * 1024
257 #ifndef OPENSSL_NO_RSA
258 static double rsa_results[RSA_NUM][2];
260 #ifndef OPENSSL_NO_DSA
261 static double dsa_results[DSA_NUM][2];
263 #ifndef OPENSSL_NO_EC
264 static double ecdsa_results[EC_NUM][2];
265 static double ecdh_results[EC_NUM][1];
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";
274 # if defined(__STDC__) || defined(sgi) || defined(_AIX)
275 # define SIGRETTYPE void
277 # define SIGRETTYPE int
280 static SIGRETTYPE sig_done(int sig);
281 static SIGRETTYPE sig_done(int sig)
283 signal(SIGALRM, sig_done);
293 # if !defined(SIGALRM)
296 static unsigned int lapse, schlock;
297 static void alarm_win32(unsigned int secs)
302 # define alarm alarm_win32
304 static DWORD WINAPI sleepy(VOID * arg)
312 static double Time_F(int s)
319 thr = CreateThread(NULL, 4096, sleepy, NULL, 0, NULL);
321 DWORD err = GetLastError();
322 BIO_printf(bio_err, "unable to CreateThread (%lu)", err);
326 Sleep(0); /* scheduler spinlock */
327 ret = app_tminterval(s, usertime);
329 ret = app_tminterval(s, usertime);
331 TerminateThread(thr, 0);
339 static double Time_F(int s)
341 double ret = app_tminterval(s, usertime);
348 static void multiblock_speed(const EVP_CIPHER *evp_cipher);
350 static int found(const char *name, const OPT_PAIR *pairs, int *result)
352 for (; pairs->name; pairs++)
353 if (strcmp(name, pairs->name) == 0) {
354 *result = pairs->retval;
360 typedef enum OPTION_choice {
361 OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
362 OPT_ELAPSED, OPT_EVP, OPT_DECRYPT, OPT_ENGINE, OPT_MULTI,
363 OPT_MR, OPT_MB, OPT_MISALIGN, OPT_ASYNCJOBS
366 const OPTIONS speed_options[] = {
367 {OPT_HELP_STR, 1, '-', "Usage: %s [options] ciphers...\n"},
368 {OPT_HELP_STR, 1, '-', "Valid options are:\n"},
369 {"help", OPT_HELP, '-', "Display this summary"},
370 {"evp", OPT_EVP, 's', "Use specified EVP cipher"},
371 {"decrypt", OPT_DECRYPT, '-',
372 "Time decryption instead of encryption (only EVP)"},
373 {"mr", OPT_MR, '-', "Produce machine readable output"},
375 "Enable (tls1.1) multi-block mode on evp_cipher requested with -evp"},
376 {"misalign", OPT_MISALIGN, 'n', "Amount to mis-align buffers"},
377 {"elapsed", OPT_ELAPSED, '-',
378 "Measure time in real time instead of CPU user time"},
380 {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"},
382 #ifndef OPENSSL_NO_ASYNC
383 {"async_jobs", OPT_ASYNCJOBS, 'p',
384 "Enable async mode and start pnum jobs"},
386 #ifndef OPENSSL_NO_ENGINE
387 {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
402 #define D_CBC_IDEA 10
403 #define D_CBC_SEED 11
407 #define D_CBC_CAST 15
408 #define D_CBC_128_AES 16
409 #define D_CBC_192_AES 17
410 #define D_CBC_256_AES 18
411 #define D_CBC_128_CML 19
412 #define D_CBC_192_CML 20
413 #define D_CBC_256_CML 21
417 #define D_WHIRLPOOL 25
418 #define D_IGE_128_AES 26
419 #define D_IGE_192_AES 27
420 #define D_IGE_256_AES 28
422 static OPT_PAIR doit_choices[] = {
423 #ifndef OPENSSL_NO_MD2
426 #ifndef OPENSSL_NO_MDC2
429 #ifndef OPENSSL_NO_MD4
432 #ifndef OPENSSL_NO_MD5
437 {"sha256", D_SHA256},
438 {"sha512", D_SHA512},
439 #ifndef OPENSSL_NO_WHIRLPOOL
440 {"whirlpool", D_WHIRLPOOL},
442 #ifndef OPENSSL_NO_RMD160
443 {"ripemd", D_RMD160},
444 {"rmd160", D_RMD160},
445 {"ripemd160", D_RMD160},
447 #ifndef OPENSSL_NO_RC4
450 #ifndef OPENSSL_NO_DES
451 {"des-cbc", D_CBC_DES},
452 {"des-ede3", D_EDE3_DES},
454 {"aes-128-cbc", D_CBC_128_AES},
455 {"aes-192-cbc", D_CBC_192_AES},
456 {"aes-256-cbc", D_CBC_256_AES},
457 {"aes-128-ige", D_IGE_128_AES},
458 {"aes-192-ige", D_IGE_192_AES},
459 {"aes-256-ige", D_IGE_256_AES},
460 #ifndef OPENSSL_NO_RC2
461 {"rc2-cbc", D_CBC_RC2},
464 #ifndef OPENSSL_NO_RC5
465 {"rc5-cbc", D_CBC_RC5},
468 #ifndef OPENSSL_NO_IDEA
469 {"idea-cbc", D_CBC_IDEA},
470 {"idea", D_CBC_IDEA},
472 #ifndef OPENSSL_NO_SEED
473 {"seed-cbc", D_CBC_SEED},
474 {"seed", D_CBC_SEED},
476 #ifndef OPENSSL_NO_BF
477 {"bf-cbc", D_CBC_BF},
478 {"blowfish", D_CBC_BF},
481 #ifndef OPENSSL_NO_CAST
482 {"cast-cbc", D_CBC_CAST},
483 {"cast", D_CBC_CAST},
484 {"cast5", D_CBC_CAST},
490 #ifndef OPENSSL_NO_DSA
492 # define R_DSA_1024 1
493 # define R_DSA_2048 2
494 static OPT_PAIR dsa_choices[] = {
495 {"dsa512", R_DSA_512},
496 {"dsa1024", R_DSA_1024},
497 {"dsa2048", R_DSA_2048},
508 #define R_RSA_15360 6
509 static OPT_PAIR rsa_choices[] = {
510 {"rsa512", R_RSA_512},
511 {"rsa1024", R_RSA_1024},
512 {"rsa2048", R_RSA_2048},
513 {"rsa3072", R_RSA_3072},
514 {"rsa4096", R_RSA_4096},
515 {"rsa7680", R_RSA_7680},
516 {"rsa15360", R_RSA_15360},
536 #define R_EC_X25519 16
537 #ifndef OPENSSL_NO_EC
538 static OPT_PAIR ecdsa_choices[] = {
539 {"ecdsap160", R_EC_P160},
540 {"ecdsap192", R_EC_P192},
541 {"ecdsap224", R_EC_P224},
542 {"ecdsap256", R_EC_P256},
543 {"ecdsap384", R_EC_P384},
544 {"ecdsap521", R_EC_P521},
545 {"ecdsak163", R_EC_K163},
546 {"ecdsak233", R_EC_K233},
547 {"ecdsak283", R_EC_K283},
548 {"ecdsak409", R_EC_K409},
549 {"ecdsak571", R_EC_K571},
550 {"ecdsab163", R_EC_B163},
551 {"ecdsab233", R_EC_B233},
552 {"ecdsab283", R_EC_B283},
553 {"ecdsab409", R_EC_B409},
554 {"ecdsab571", R_EC_B571},
558 static OPT_PAIR ecdh_choices[] = {
559 {"ecdhp160", R_EC_P160},
560 {"ecdhp192", R_EC_P192},
561 {"ecdhp224", R_EC_P224},
562 {"ecdhp256", R_EC_P256},
563 {"ecdhp384", R_EC_P384},
564 {"ecdhp521", R_EC_P521},
565 {"ecdhk163", R_EC_K163},
566 {"ecdhk233", R_EC_K233},
567 {"ecdhk283", R_EC_K283},
568 {"ecdhk409", R_EC_K409},
569 {"ecdhk571", R_EC_K571},
570 {"ecdhb163", R_EC_B163},
571 {"ecdhb233", R_EC_B233},
572 {"ecdhb283", R_EC_B283},
573 {"ecdhb409", R_EC_B409},
574 {"ecdhb571", R_EC_B571},
575 {"ecdhx25519", R_EC_X25519},
581 # define COND(d) (count < (d))
582 # define COUNT(d) (d)
584 # define COND(unused_cond) (run && count<0x7fffffff)
585 # define COUNT(d) (count)
590 /* Nb of iterations to do per algorithm and key-size */
591 static long c[ALGOR_NUM][SIZE_NUM];
593 #ifndef OPENSSL_NO_MD2
594 static int EVP_Digest_MD2_loop(void *args)
596 loopargs_t *tempargs = *(loopargs_t **)args;
597 unsigned char *buf = tempargs->buf;
598 unsigned char md2[MD2_DIGEST_LENGTH];
601 for (count = 0; COND(c[D_MD2][testnum]); count++) {
602 if (!EVP_Digest(buf, (size_t)lengths[testnum], md2, NULL, EVP_md2(),
610 #ifndef OPENSSL_NO_MDC2
611 static int EVP_Digest_MDC2_loop(void *args)
613 loopargs_t *tempargs = *(loopargs_t **)args;
614 unsigned char *buf = tempargs->buf;
615 unsigned char mdc2[MDC2_DIGEST_LENGTH];
618 for (count = 0; COND(c[D_MDC2][testnum]); count++) {
619 if (!EVP_Digest(buf, (size_t)lengths[testnum], mdc2, NULL, EVP_mdc2(),
627 #ifndef OPENSSL_NO_MD4
628 static int EVP_Digest_MD4_loop(void *args)
630 loopargs_t *tempargs = *(loopargs_t **)args;
631 unsigned char *buf = tempargs->buf;
632 unsigned char md4[MD4_DIGEST_LENGTH];
635 for (count = 0; COND(c[D_MD4][testnum]); count++) {
636 if (!EVP_Digest(buf, (size_t)lengths[testnum], md4, NULL, EVP_md4(),
644 #ifndef OPENSSL_NO_MD5
645 static int MD5_loop(void *args)
647 loopargs_t *tempargs = *(loopargs_t **)args;
648 unsigned char *buf = tempargs->buf;
649 unsigned char md5[MD5_DIGEST_LENGTH];
651 for (count = 0; COND(c[D_MD5][testnum]); count++)
652 MD5(buf, lengths[testnum], md5);
656 static int HMAC_loop(void *args)
658 loopargs_t *tempargs = *(loopargs_t **)args;
659 unsigned char *buf = tempargs->buf;
660 HMAC_CTX *hctx = tempargs->hctx;
661 unsigned char hmac[MD5_DIGEST_LENGTH];
664 for (count = 0; COND(c[D_HMAC][testnum]); count++) {
665 HMAC_Init_ex(hctx, NULL, 0, NULL, NULL);
666 HMAC_Update(hctx, buf, lengths[testnum]);
667 HMAC_Final(hctx, hmac, NULL);
673 static int SHA1_loop(void *args)
675 loopargs_t *tempargs = *(loopargs_t **)args;
676 unsigned char *buf = tempargs->buf;
677 unsigned char sha[SHA_DIGEST_LENGTH];
679 for (count = 0; COND(c[D_SHA1][testnum]); count++)
680 SHA1(buf, lengths[testnum], sha);
684 static int SHA256_loop(void *args)
686 loopargs_t *tempargs = *(loopargs_t **)args;
687 unsigned char *buf = tempargs->buf;
688 unsigned char sha256[SHA256_DIGEST_LENGTH];
690 for (count = 0; COND(c[D_SHA256][testnum]); count++)
691 SHA256(buf, lengths[testnum], sha256);
695 static int SHA512_loop(void *args)
697 loopargs_t *tempargs = *(loopargs_t **)args;
698 unsigned char *buf = tempargs->buf;
699 unsigned char sha512[SHA512_DIGEST_LENGTH];
701 for (count = 0; COND(c[D_SHA512][testnum]); count++)
702 SHA512(buf, lengths[testnum], sha512);
706 #ifndef OPENSSL_NO_WHIRLPOOL
707 static int WHIRLPOOL_loop(void *args)
709 loopargs_t *tempargs = *(loopargs_t **)args;
710 unsigned char *buf = tempargs->buf;
711 unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];
713 for (count = 0; COND(c[D_WHIRLPOOL][testnum]); count++)
714 WHIRLPOOL(buf, lengths[testnum], whirlpool);
719 #ifndef OPENSSL_NO_RMD160
720 static int EVP_Digest_RMD160_loop(void *args)
722 loopargs_t *tempargs = *(loopargs_t **)args;
723 unsigned char *buf = tempargs->buf;
724 unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
726 for (count = 0; COND(c[D_RMD160][testnum]); count++) {
727 if (!EVP_Digest(buf, (size_t)lengths[testnum], &(rmd160[0]),
728 NULL, EVP_ripemd160(), NULL))
735 #ifndef OPENSSL_NO_RC4
736 static RC4_KEY rc4_ks;
737 static int RC4_loop(void *args)
739 loopargs_t *tempargs = *(loopargs_t **)args;
740 unsigned char *buf = tempargs->buf;
742 for (count = 0; COND(c[D_RC4][testnum]); count++)
743 RC4(&rc4_ks, (size_t)lengths[testnum], buf, buf);
748 #ifndef OPENSSL_NO_DES
749 static unsigned char DES_iv[8];
750 static DES_key_schedule sch;
751 static DES_key_schedule sch2;
752 static DES_key_schedule sch3;
753 static int DES_ncbc_encrypt_loop(void *args)
755 loopargs_t *tempargs = *(loopargs_t **)args;
756 unsigned char *buf = tempargs->buf;
758 for (count = 0; COND(c[D_CBC_DES][testnum]); count++)
759 DES_ncbc_encrypt(buf, buf, lengths[testnum], &sch,
760 &DES_iv, DES_ENCRYPT);
764 static int DES_ede3_cbc_encrypt_loop(void *args)
766 loopargs_t *tempargs = *(loopargs_t **)args;
767 unsigned char *buf = tempargs->buf;
769 for (count = 0; COND(c[D_EDE3_DES][testnum]); count++)
770 DES_ede3_cbc_encrypt(buf, buf, lengths[testnum],
772 &DES_iv, DES_ENCRYPT);
777 #define MAX_BLOCK_SIZE 128
779 static unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
780 static AES_KEY aes_ks1, aes_ks2, aes_ks3;
781 static int AES_cbc_128_encrypt_loop(void *args)
783 loopargs_t *tempargs = *(loopargs_t **)args;
784 unsigned char *buf = tempargs->buf;
786 for (count = 0; COND(c[D_CBC_128_AES][testnum]); count++)
787 AES_cbc_encrypt(buf, buf,
788 (size_t)lengths[testnum], &aes_ks1,
793 static int AES_cbc_192_encrypt_loop(void *args)
795 loopargs_t *tempargs = *(loopargs_t **)args;
796 unsigned char *buf = tempargs->buf;
798 for (count = 0; COND(c[D_CBC_192_AES][testnum]); count++)
799 AES_cbc_encrypt(buf, buf,
800 (size_t)lengths[testnum], &aes_ks2,
805 static int AES_cbc_256_encrypt_loop(void *args)
807 loopargs_t *tempargs = *(loopargs_t **)args;
808 unsigned char *buf = tempargs->buf;
810 for (count = 0; COND(c[D_CBC_256_AES][testnum]); count++)
811 AES_cbc_encrypt(buf, buf,
812 (size_t)lengths[testnum], &aes_ks3,
817 static int AES_ige_128_encrypt_loop(void *args)
819 loopargs_t *tempargs = *(loopargs_t **)args;
820 unsigned char *buf = tempargs->buf;
821 unsigned char *buf2 = tempargs->buf2;
823 for (count = 0; COND(c[D_IGE_128_AES][testnum]); count++)
824 AES_ige_encrypt(buf, buf2,
825 (size_t)lengths[testnum], &aes_ks1,
830 static int AES_ige_192_encrypt_loop(void *args)
832 loopargs_t *tempargs = *(loopargs_t **)args;
833 unsigned char *buf = tempargs->buf;
834 unsigned char *buf2 = tempargs->buf2;
836 for (count = 0; COND(c[D_IGE_192_AES][testnum]); count++)
837 AES_ige_encrypt(buf, buf2,
838 (size_t)lengths[testnum], &aes_ks2,
843 static int AES_ige_256_encrypt_loop(void *args)
845 loopargs_t *tempargs = *(loopargs_t **)args;
846 unsigned char *buf = tempargs->buf;
847 unsigned char *buf2 = tempargs->buf2;
849 for (count = 0; COND(c[D_IGE_256_AES][testnum]); count++)
850 AES_ige_encrypt(buf, buf2,
851 (size_t)lengths[testnum], &aes_ks3,
856 static int CRYPTO_gcm128_aad_loop(void *args)
858 loopargs_t *tempargs = *(loopargs_t **)args;
859 unsigned char *buf = tempargs->buf;
860 GCM128_CONTEXT *gcm_ctx = tempargs->gcm_ctx;
862 for (count = 0; COND(c[D_GHASH][testnum]); count++)
863 CRYPTO_gcm128_aad(gcm_ctx, buf, lengths[testnum]);
867 static long save_count = 0;
868 static int decrypt = 0;
869 static int EVP_Update_loop(void *args)
871 loopargs_t *tempargs = *(loopargs_t **)args;
872 unsigned char *buf = tempargs->buf;
873 EVP_CIPHER_CTX *ctx = tempargs->ctx;
876 int nb_iter = save_count * 4 * lengths[0] / lengths[testnum];
879 for (count = 0; COND(nb_iter); count++)
880 EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
882 for (count = 0; COND(nb_iter); count++)
883 EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
885 EVP_DecryptFinal_ex(ctx, buf, &outl);
887 EVP_EncryptFinal_ex(ctx, buf, &outl);
891 static const EVP_MD *evp_md = NULL;
892 static int EVP_Digest_loop(void *args)
894 loopargs_t *tempargs = *(loopargs_t **)args;
895 unsigned char *buf = tempargs->buf;
896 unsigned char md[EVP_MAX_MD_SIZE];
899 int nb_iter = save_count * 4 * lengths[0] / lengths[testnum];
902 for (count = 0; COND(nb_iter); count++) {
903 if (!EVP_Digest(buf, lengths[testnum], md, NULL, evp_md, NULL))
909 #ifndef OPENSSL_NO_RSA
910 static long rsa_c[RSA_NUM][2]; /* # RSA iteration test */
912 static int RSA_sign_loop(void *args)
914 loopargs_t *tempargs = *(loopargs_t **)args;
915 unsigned char *buf = tempargs->buf;
916 unsigned char *buf2 = tempargs->buf2;
917 unsigned int *rsa_num = &tempargs->siglen;
918 RSA **rsa_key = tempargs->rsa_key;
920 for (count = 0; COND(rsa_c[testnum][0]); count++) {
921 ret = RSA_sign(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
923 BIO_printf(bio_err, "RSA sign failure\n");
924 ERR_print_errors(bio_err);
932 static int RSA_verify_loop(void *args)
934 loopargs_t *tempargs = *(loopargs_t **)args;
935 unsigned char *buf = tempargs->buf;
936 unsigned char *buf2 = tempargs->buf2;
937 unsigned int rsa_num = tempargs->siglen;
938 RSA **rsa_key = tempargs->rsa_key;
940 for (count = 0; COND(rsa_c[testnum][1]); count++) {
941 ret = RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
943 BIO_printf(bio_err, "RSA verify failure\n");
944 ERR_print_errors(bio_err);
953 #ifndef OPENSSL_NO_DSA
954 static long dsa_c[DSA_NUM][2];
955 static int DSA_sign_loop(void *args)
957 loopargs_t *tempargs = *(loopargs_t **)args;
958 unsigned char *buf = tempargs->buf;
959 unsigned char *buf2 = tempargs->buf2;
960 DSA **dsa_key = tempargs->dsa_key;
961 unsigned int *siglen = &tempargs->siglen;
963 for (count = 0; COND(dsa_c[testnum][0]); count++) {
964 ret = DSA_sign(0, buf, 20, buf2, siglen, dsa_key[testnum]);
966 BIO_printf(bio_err, "DSA sign failure\n");
967 ERR_print_errors(bio_err);
975 static int DSA_verify_loop(void *args)
977 loopargs_t *tempargs = *(loopargs_t **)args;
978 unsigned char *buf = tempargs->buf;
979 unsigned char *buf2 = tempargs->buf2;
980 DSA **dsa_key = tempargs->dsa_key;
981 unsigned int siglen = tempargs->siglen;
983 for (count = 0; COND(dsa_c[testnum][1]); count++) {
984 ret = DSA_verify(0, buf, 20, buf2, siglen, dsa_key[testnum]);
986 BIO_printf(bio_err, "DSA verify failure\n");
987 ERR_print_errors(bio_err);
996 #ifndef OPENSSL_NO_EC
997 static long ecdsa_c[EC_NUM][2];
998 static int ECDSA_sign_loop(void *args)
1000 loopargs_t *tempargs = *(loopargs_t **)args;
1001 unsigned char *buf = tempargs->buf;
1002 EC_KEY **ecdsa = tempargs->ecdsa;
1003 unsigned char *ecdsasig = tempargs->buf2;
1004 unsigned int *ecdsasiglen = &tempargs->siglen;
1006 for (count = 0; COND(ecdsa_c[testnum][0]); count++) {
1007 ret = ECDSA_sign(0, buf, 20,
1008 ecdsasig, ecdsasiglen, ecdsa[testnum]);
1010 BIO_printf(bio_err, "ECDSA sign failure\n");
1011 ERR_print_errors(bio_err);
1019 static int ECDSA_verify_loop(void *args)
1021 loopargs_t *tempargs = *(loopargs_t **)args;
1022 unsigned char *buf = tempargs->buf;
1023 EC_KEY **ecdsa = tempargs->ecdsa;
1024 unsigned char *ecdsasig = tempargs->buf2;
1025 unsigned int ecdsasiglen = tempargs->siglen;
1027 for (count = 0; COND(ecdsa_c[testnum][1]); count++) {
1028 ret = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen,
1031 BIO_printf(bio_err, "ECDSA verify failure\n");
1032 ERR_print_errors(bio_err);
1040 /* ******************************************************************** */
1041 static long ecdh_c[EC_NUM][1];
1043 static int ECDH_compute_key_loop(void *args)
1045 loopargs_t *tempargs = *(loopargs_t **)args;
1046 EC_KEY **ecdh_a = tempargs->ecdh_a;
1047 EC_KEY **ecdh_b = tempargs->ecdh_b;
1048 unsigned char *secret_a = tempargs->secret_a;
1050 size_t outlen = tempargs->outlen;
1051 kdf_fn kdf = tempargs->kdf;
1053 for (count = 0; COND(ecdh_c[testnum][0]); count++) {
1054 ECDH_compute_key(secret_a, outlen,
1055 EC_KEY_get0_public_key(ecdh_b[testnum]),
1056 ecdh_a[testnum], kdf);
1061 static const size_t KDF1_SHA1_len = 20;
1062 static void *KDF1_SHA1(const void *in, size_t inlen, void *out,
1065 if (*outlen < SHA_DIGEST_LENGTH)
1067 *outlen = SHA_DIGEST_LENGTH;
1068 return SHA1(in, inlen, out);
1070 #endif /* OPENSSL_NO_EC */
1072 static int run_benchmark(int async_jobs,
1073 int (*loop_function)(void *), loopargs_t *loopargs)
1075 int job_op_count = 0;
1076 int total_op_count = 0;
1077 int num_inprogress = 0;
1078 int error = 0, i = 0, ret = 0;
1079 OSSL_ASYNC_FD job_fd = 0;
1080 size_t num_job_fds = 0;
1084 if (async_jobs == 0) {
1085 return loop_function((void *)&loopargs);
1088 for (i = 0; i < async_jobs && !error; i++) {
1089 loopargs_t *looparg_item = loopargs + i;
1091 /* Copy pointer content (looparg_t item address) into async context */
1092 ret = ASYNC_start_job(&loopargs[i].inprogress_job, loopargs[i].wait_ctx,
1093 &job_op_count, loop_function,
1094 (void *)&looparg_item, sizeof(looparg_item));
1100 if (job_op_count == -1) {
1103 total_op_count += job_op_count;
1108 BIO_printf(bio_err, "Failure in the job\n");
1109 ERR_print_errors(bio_err);
1115 while (num_inprogress > 0) {
1116 #if defined(OPENSSL_SYS_WINDOWS)
1118 #elif defined(OPENSSL_SYS_UNIX)
1119 int select_result = 0;
1120 OSSL_ASYNC_FD max_fd = 0;
1123 FD_ZERO(&waitfdset);
1125 for (i = 0; i < async_jobs && num_inprogress > 0; i++) {
1126 if (loopargs[i].inprogress_job == NULL)
1129 if (!ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, NULL, &num_job_fds)
1130 || num_job_fds > 1) {
1131 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1132 ERR_print_errors(bio_err);
1136 ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd, &num_job_fds);
1137 FD_SET(job_fd, &waitfdset);
1138 if (job_fd > max_fd)
1142 if (max_fd >= (OSSL_ASYNC_FD)FD_SETSIZE) {
1144 "Error: max_fd (%d) must be smaller than FD_SETSIZE (%d). "
1145 "Decrease the value of async_jobs\n",
1146 max_fd, FD_SETSIZE);
1147 ERR_print_errors(bio_err);
1152 select_result = select(max_fd + 1, &waitfdset, NULL, NULL, NULL);
1153 if (select_result == -1 && errno == EINTR)
1156 if (select_result == -1) {
1157 BIO_printf(bio_err, "Failure in the select\n");
1158 ERR_print_errors(bio_err);
1163 if (select_result == 0)
1167 for (i = 0; i < async_jobs; i++) {
1168 if (loopargs[i].inprogress_job == NULL)
1171 if (!ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, NULL, &num_job_fds)
1172 || num_job_fds > 1) {
1173 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1174 ERR_print_errors(bio_err);
1178 ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd, &num_job_fds);
1180 #if defined(OPENSSL_SYS_UNIX)
1181 if (num_job_fds == 1 && !FD_ISSET(job_fd, &waitfdset))
1183 #elif defined(OPENSSL_SYS_WINDOWS)
1184 if (num_job_fds == 1
1185 && !PeekNamedPipe(job_fd, NULL, 0, NULL, &avail, NULL)
1190 ret = ASYNC_start_job(&loopargs[i].inprogress_job,
1191 loopargs[i].wait_ctx, &job_op_count, loop_function,
1192 (void *)(loopargs + i), sizeof(loopargs_t));
1197 if (job_op_count == -1) {
1200 total_op_count += job_op_count;
1203 loopargs[i].inprogress_job = NULL;
1208 loopargs[i].inprogress_job = NULL;
1209 BIO_printf(bio_err, "Failure in the job\n");
1210 ERR_print_errors(bio_err);
1217 return error ? -1 : total_op_count;
1220 int speed_main(int argc, char **argv)
1223 loopargs_t *loopargs = NULL;
1225 int loopargs_len = 0;
1227 const char *engine_id = NULL;
1228 const EVP_CIPHER *evp_cipher = NULL;
1231 int multiblock = 0, pr_header = 0;
1232 int doit[ALGOR_NUM] = { 0 };
1233 int ret = 1, i, k, misalign = 0;
1239 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) \
1240 || !defined(OPENSSL_NO_EC)
1244 /* What follows are the buffers and key material. */
1245 #ifndef OPENSSL_NO_RC5
1248 #ifndef OPENSSL_NO_RC2
1251 #ifndef OPENSSL_NO_IDEA
1252 IDEA_KEY_SCHEDULE idea_ks;
1254 #ifndef OPENSSL_NO_SEED
1255 SEED_KEY_SCHEDULE seed_ks;
1257 #ifndef OPENSSL_NO_BF
1260 #ifndef OPENSSL_NO_CAST
1263 static const unsigned char key16[16] = {
1264 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1265 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1267 static const unsigned char key24[24] = {
1268 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1269 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1270 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1272 static const unsigned char key32[32] = {
1273 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1274 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1275 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1276 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1278 #ifndef OPENSSL_NO_CAMELLIA
1279 static const unsigned char ckey24[24] = {
1280 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1281 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1282 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1284 static const unsigned char ckey32[32] = {
1285 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1286 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1287 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1288 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1290 CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
1292 #ifndef OPENSSL_NO_DES
1293 static DES_cblock key = {
1294 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
1296 static DES_cblock key2 = {
1297 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1299 static DES_cblock key3 = {
1300 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1303 #ifndef OPENSSL_NO_RSA
1304 static const unsigned int rsa_bits[RSA_NUM] = {
1305 512, 1024, 2048, 3072, 4096, 7680, 15360
1307 static const unsigned char *rsa_data[RSA_NUM] = {
1308 test512, test1024, test2048, test3072, test4096, test7680, test15360
1310 static const int rsa_data_length[RSA_NUM] = {
1311 sizeof(test512), sizeof(test1024),
1312 sizeof(test2048), sizeof(test3072),
1313 sizeof(test4096), sizeof(test7680),
1316 int rsa_doit[RSA_NUM] = { 0 };
1318 #ifndef OPENSSL_NO_DSA
1319 static const unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
1320 int dsa_doit[DSA_NUM] = { 0 };
1322 #ifndef OPENSSL_NO_EC
1324 * We only test over the following curves as they are representative, To
1325 * add tests over more curves, simply add the curve NID and curve name to
1326 * the following arrays and increase the EC_NUM value accordingly.
1328 static const unsigned int test_curves[EC_NUM] = {
1330 NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
1331 NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
1333 NID_sect163k1, NID_sect233k1, NID_sect283k1,
1334 NID_sect409k1, NID_sect571k1, NID_sect163r2,
1335 NID_sect233r1, NID_sect283r1, NID_sect409r1,
1340 static const char *test_curves_names[EC_NUM] = {
1342 "secp160r1", "nistp192", "nistp224",
1343 "nistp256", "nistp384", "nistp521",
1345 "nistk163", "nistk233", "nistk283",
1346 "nistk409", "nistk571", "nistb163",
1347 "nistb233", "nistb283", "nistb409",
1352 static const int test_curves_bits[EC_NUM] = {
1358 571, 253 /* X25519 */
1361 int ecdsa_doit[EC_NUM] = { 0 };
1362 int ecdh_doit[EC_NUM] = { 0 };
1363 #endif /* ndef OPENSSL_NO_EC */
1365 prog = opt_init(argc, argv, speed_options);
1366 while ((o = opt_next()) != OPT_EOF) {
1371 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
1374 opt_help(speed_options);
1381 evp_cipher = EVP_get_cipherbyname(opt_arg());
1382 if (evp_cipher == NULL)
1383 evp_md = EVP_get_digestbyname(opt_arg());
1384 if (evp_cipher == NULL && evp_md == NULL) {
1386 "%s: %s is an unknown cipher or digest\n",
1397 * In a forked execution, an engine might need to be
1398 * initialised by each child process, not by the parent.
1399 * So store the name here and run setup_engine() later on.
1401 engine_id = opt_arg();
1405 multi = atoi(opt_arg());
1409 #ifndef OPENSSL_NO_ASYNC
1410 async_jobs = atoi(opt_arg());
1411 if (!ASYNC_is_capable()) {
1413 "%s: async_jobs specified but async not supported\n",
1420 if (!opt_int(opt_arg(), &misalign))
1422 if (misalign > MISALIGN) {
1424 "%s: Maximum offset is %d\n", prog, MISALIGN);
1433 #ifdef OPENSSL_NO_MULTIBLOCK
1435 "%s: -mb specified but multi-block support is disabled\n",
1442 argc = opt_num_rest();
1445 /* Remaining arguments are algorithms. */
1446 for ( ; *argv; argv++) {
1447 if (found(*argv, doit_choices, &i)) {
1451 #ifndef OPENSSL_NO_DES
1452 if (strcmp(*argv, "des") == 0) {
1453 doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
1457 if (strcmp(*argv, "sha") == 0) {
1458 doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
1461 #ifndef OPENSSL_NO_RSA
1463 if (strcmp(*argv, "openssl") == 0) {
1464 RSA_set_default_method(RSA_PKCS1_OpenSSL());
1468 if (strcmp(*argv, "rsa") == 0) {
1469 rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
1470 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
1471 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
1472 rsa_doit[R_RSA_15360] = 1;
1475 if (found(*argv, rsa_choices, &i)) {
1480 #ifndef OPENSSL_NO_DSA
1481 if (strcmp(*argv, "dsa") == 0) {
1482 dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
1483 dsa_doit[R_DSA_2048] = 1;
1486 if (found(*argv, dsa_choices, &i)) {
1491 if (strcmp(*argv, "aes") == 0) {
1492 doit[D_CBC_128_AES] = doit[D_CBC_192_AES] =
1493 doit[D_CBC_256_AES] = 1;
1496 #ifndef OPENSSL_NO_CAMELLIA
1497 if (strcmp(*argv, "camellia") == 0) {
1498 doit[D_CBC_128_CML] = doit[D_CBC_192_CML] =
1499 doit[D_CBC_256_CML] = 1;
1503 #ifndef OPENSSL_NO_EC
1504 if (strcmp(*argv, "ecdsa") == 0) {
1505 for (i = 0; i < EC_NUM; i++)
1509 if (found(*argv, ecdsa_choices, &i)) {
1513 if (strcmp(*argv, "ecdh") == 0) {
1514 for (i = 0; i < EC_NUM; i++)
1518 if (found(*argv, ecdh_choices, &i)) {
1523 BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
1527 /* Initialize the job pool if async mode is enabled */
1528 if (async_jobs > 0) {
1529 async_init = ASYNC_init_thread(async_jobs, async_jobs);
1531 BIO_printf(bio_err, "Error creating the ASYNC job pool\n");
1536 loopargs_len = (async_jobs == 0 ? 1 : async_jobs);
1537 loopargs = app_malloc(loopargs_len * sizeof(loopargs_t), "array of loopargs");
1538 memset(loopargs, 0, loopargs_len * sizeof(loopargs_t));
1540 for (i = 0; i < loopargs_len; i++) {
1541 if (async_jobs > 0) {
1542 loopargs[i].wait_ctx = ASYNC_WAIT_CTX_new();
1543 if (loopargs[i].wait_ctx == NULL) {
1544 BIO_printf(bio_err, "Error creating the ASYNC_WAIT_CTX\n");
1549 loopargs[i].buf_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1550 loopargs[i].buf2_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1551 /* Align the start of buffers on a 64 byte boundary */
1552 loopargs[i].buf = loopargs[i].buf_malloc + misalign;
1553 loopargs[i].buf2 = loopargs[i].buf2_malloc + misalign;
1554 #ifndef OPENSSL_NO_EC
1555 loopargs[i].secret_a = app_malloc(MAX_ECDH_SIZE, "ECDH secret a");
1556 loopargs[i].secret_b = app_malloc(MAX_ECDH_SIZE, "ECDH secret b");
1561 if (multi && do_multi(multi))
1565 /* Initialize the engine after the fork */
1566 e = setup_engine(engine_id, 0);
1568 /* No parameters; turn on everything. */
1569 if ((argc == 0) && !doit[D_EVP]) {
1570 for (i = 0; i < ALGOR_NUM; i++)
1573 #ifndef OPENSSL_NO_RSA
1574 for (i = 0; i < RSA_NUM; i++)
1577 #ifndef OPENSSL_NO_DSA
1578 for (i = 0; i < DSA_NUM; i++)
1581 #ifndef OPENSSL_NO_EC
1582 for (i = 0; i < EC_NUM; i++)
1584 for (i = 0; i < EC_NUM; i++)
1588 for (i = 0; i < ALGOR_NUM; i++)
1592 if (usertime == 0 && !mr)
1594 "You have chosen to measure elapsed time "
1595 "instead of user CPU time.\n");
1597 #ifndef OPENSSL_NO_RSA
1598 for (i = 0; i < loopargs_len; i++) {
1599 for (k = 0; k < RSA_NUM; k++) {
1600 const unsigned char *p;
1603 loopargs[i].rsa_key[k] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[k]);
1604 if (loopargs[i].rsa_key[k] == NULL) {
1605 BIO_printf(bio_err, "internal error loading RSA key number %d\n",
1612 #ifndef OPENSSL_NO_DSA
1613 for (i = 0; i < loopargs_len; i++) {
1614 loopargs[i].dsa_key[0] = get_dsa512();
1615 loopargs[i].dsa_key[1] = get_dsa1024();
1616 loopargs[i].dsa_key[2] = get_dsa2048();
1619 #ifndef OPENSSL_NO_DES
1620 DES_set_key_unchecked(&key, &sch);
1621 DES_set_key_unchecked(&key2, &sch2);
1622 DES_set_key_unchecked(&key3, &sch3);
1624 AES_set_encrypt_key(key16, 128, &aes_ks1);
1625 AES_set_encrypt_key(key24, 192, &aes_ks2);
1626 AES_set_encrypt_key(key32, 256, &aes_ks3);
1627 #ifndef OPENSSL_NO_CAMELLIA
1628 Camellia_set_key(key16, 128, &camellia_ks1);
1629 Camellia_set_key(ckey24, 192, &camellia_ks2);
1630 Camellia_set_key(ckey32, 256, &camellia_ks3);
1632 #ifndef OPENSSL_NO_IDEA
1633 IDEA_set_encrypt_key(key16, &idea_ks);
1635 #ifndef OPENSSL_NO_SEED
1636 SEED_set_key(key16, &seed_ks);
1638 #ifndef OPENSSL_NO_RC4
1639 RC4_set_key(&rc4_ks, 16, key16);
1641 #ifndef OPENSSL_NO_RC2
1642 RC2_set_key(&rc2_ks, 16, key16, 128);
1644 #ifndef OPENSSL_NO_RC5
1645 RC5_32_set_key(&rc5_ks, 16, key16, 12);
1647 #ifndef OPENSSL_NO_BF
1648 BF_set_key(&bf_ks, 16, key16);
1650 #ifndef OPENSSL_NO_CAST
1651 CAST_set_key(&cast_ks, 16, key16);
1654 # ifndef OPENSSL_NO_DES
1655 BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1661 for (it = count; it; it--)
1662 DES_ecb_encrypt((DES_cblock *)loopargs[0].buf,
1663 (DES_cblock *)loopargs[0].buf, &sch, DES_ENCRYPT);
1667 c[D_MD2][0] = count / 10;
1668 c[D_MDC2][0] = count / 10;
1669 c[D_MD4][0] = count;
1670 c[D_MD5][0] = count;
1671 c[D_HMAC][0] = count;
1672 c[D_SHA1][0] = count;
1673 c[D_RMD160][0] = count;
1674 c[D_RC4][0] = count * 5;
1675 c[D_CBC_DES][0] = count;
1676 c[D_EDE3_DES][0] = count / 3;
1677 c[D_CBC_IDEA][0] = count;
1678 c[D_CBC_SEED][0] = count;
1679 c[D_CBC_RC2][0] = count;
1680 c[D_CBC_RC5][0] = count;
1681 c[D_CBC_BF][0] = count;
1682 c[D_CBC_CAST][0] = count;
1683 c[D_CBC_128_AES][0] = count;
1684 c[D_CBC_192_AES][0] = count;
1685 c[D_CBC_256_AES][0] = count;
1686 c[D_CBC_128_CML][0] = count;
1687 c[D_CBC_192_CML][0] = count;
1688 c[D_CBC_256_CML][0] = count;
1689 c[D_SHA256][0] = count;
1690 c[D_SHA512][0] = count;
1691 c[D_WHIRLPOOL][0] = count;
1692 c[D_IGE_128_AES][0] = count;
1693 c[D_IGE_192_AES][0] = count;
1694 c[D_IGE_256_AES][0] = count;
1695 c[D_GHASH][0] = count;
1697 for (i = 1; i < SIZE_NUM; i++) {
1700 l0 = (long)lengths[0];
1701 l1 = (long)lengths[i];
1703 c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1704 c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1705 c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1706 c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1707 c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1708 c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1709 c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1710 c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1711 c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1712 c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1713 c[D_GHASH][i] = c[D_GHASH][0] * 4 * l0 / l1;
1715 l0 = (long)lengths[i - 1];
1717 c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1718 c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1719 c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1720 c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1721 c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1722 c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1723 c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1724 c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1725 c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1726 c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1727 c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1728 c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1729 c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1730 c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1731 c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1732 c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1733 c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1734 c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1737 # ifndef OPENSSL_NO_RSA
1738 rsa_c[R_RSA_512][0] = count / 2000;
1739 rsa_c[R_RSA_512][1] = count / 400;
1740 for (i = 1; i < RSA_NUM; i++) {
1741 rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1742 rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1743 if (rsa_doit[i] <= 1 && rsa_c[i][0] == 0)
1746 if (rsa_c[i][0] == 0) {
1747 rsa_c[i][0] = 1; /* Set minimum iteration Nb to 1. */
1754 # ifndef OPENSSL_NO_DSA
1755 dsa_c[R_DSA_512][0] = count / 1000;
1756 dsa_c[R_DSA_512][1] = count / 1000 / 2;
1757 for (i = 1; i < DSA_NUM; i++) {
1758 dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1759 dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1760 if (dsa_doit[i] <= 1 && dsa_c[i][0] == 0)
1763 if (dsa_c[i][0] == 0) {
1764 dsa_c[i][0] = 1; /* Set minimum iteration Nb to 1. */
1771 # ifndef OPENSSL_NO_EC
1772 ecdsa_c[R_EC_P160][0] = count / 1000;
1773 ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1774 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1775 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1776 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1777 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1780 if (ecdsa_c[i][0] == 0) {
1786 ecdsa_c[R_EC_K163][0] = count / 1000;
1787 ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1788 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1789 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1790 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1791 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1794 if (ecdsa_c[i][0] == 0) {
1800 ecdsa_c[R_EC_B163][0] = count / 1000;
1801 ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1802 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1803 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1804 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1805 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1808 if (ecdsa_c[i][0] == 0) {
1815 ecdh_c[R_EC_P160][0] = count / 1000;
1816 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1817 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1818 if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1821 if (ecdh_c[i][0] == 0) {
1826 ecdh_c[R_EC_K163][0] = count / 1000;
1827 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1828 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1829 if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1832 if (ecdh_c[i][0] == 0) {
1837 ecdh_c[R_EC_B163][0] = count / 1000;
1838 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1839 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1840 if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1843 if (ecdh_c[i][0] == 0) {
1851 /* not worth fixing */
1852 # error "You cannot disable DES on systems without SIGALRM."
1853 # endif /* OPENSSL_NO_DES */
1856 signal(SIGALRM, sig_done);
1858 #endif /* SIGALRM */
1860 #ifndef OPENSSL_NO_MD2
1862 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1863 print_message(names[D_MD2], c[D_MD2][testnum], lengths[testnum]);
1865 count = run_benchmark(async_jobs, EVP_Digest_MD2_loop, loopargs);
1867 print_result(D_MD2, testnum, count, d);
1871 #ifndef OPENSSL_NO_MDC2
1873 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1874 print_message(names[D_MDC2], c[D_MDC2][testnum], lengths[testnum]);
1876 count = run_benchmark(async_jobs, EVP_Digest_MDC2_loop, loopargs);
1878 print_result(D_MDC2, testnum, count, d);
1883 #ifndef OPENSSL_NO_MD4
1885 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1886 print_message(names[D_MD4], c[D_MD4][testnum], lengths[testnum]);
1888 count = run_benchmark(async_jobs, EVP_Digest_MD4_loop, loopargs);
1890 print_result(D_MD4, testnum, count, d);
1895 #ifndef OPENSSL_NO_MD5
1897 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1898 print_message(names[D_MD5], c[D_MD5][testnum], lengths[testnum]);
1900 count = run_benchmark(async_jobs, MD5_loop, loopargs);
1902 print_result(D_MD5, testnum, count, d);
1907 static const char hmac_key[] = "This is a key...";
1908 int len = strlen(hmac_key);
1910 for (i = 0; i < loopargs_len; i++) {
1911 loopargs[i].hctx = HMAC_CTX_new();
1912 if (loopargs[i].hctx == NULL) {
1913 BIO_printf(bio_err, "HMAC malloc failure, exiting...");
1917 HMAC_Init_ex(loopargs[i].hctx, hmac_key, len, EVP_md5(), NULL);
1919 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1920 print_message(names[D_HMAC], c[D_HMAC][testnum], lengths[testnum]);
1922 count = run_benchmark(async_jobs, HMAC_loop, loopargs);
1924 print_result(D_HMAC, testnum, count, d);
1926 for (i = 0; i < loopargs_len; i++) {
1927 HMAC_CTX_free(loopargs[i].hctx);
1932 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1933 print_message(names[D_SHA1], c[D_SHA1][testnum], lengths[testnum]);
1935 count = run_benchmark(async_jobs, SHA1_loop, loopargs);
1937 print_result(D_SHA1, testnum, count, d);
1940 if (doit[D_SHA256]) {
1941 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1942 print_message(names[D_SHA256], c[D_SHA256][testnum], lengths[testnum]);
1944 count = run_benchmark(async_jobs, SHA256_loop, loopargs);
1946 print_result(D_SHA256, testnum, count, d);
1949 if (doit[D_SHA512]) {
1950 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1951 print_message(names[D_SHA512], c[D_SHA512][testnum], lengths[testnum]);
1953 count = run_benchmark(async_jobs, SHA512_loop, loopargs);
1955 print_result(D_SHA512, testnum, count, d);
1959 #ifndef OPENSSL_NO_WHIRLPOOL
1960 if (doit[D_WHIRLPOOL]) {
1961 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1962 print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][testnum], lengths[testnum]);
1964 count = run_benchmark(async_jobs, WHIRLPOOL_loop, loopargs);
1966 print_result(D_WHIRLPOOL, testnum, count, d);
1971 #ifndef OPENSSL_NO_RMD160
1972 if (doit[D_RMD160]) {
1973 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1974 print_message(names[D_RMD160], c[D_RMD160][testnum], lengths[testnum]);
1976 count = run_benchmark(async_jobs, EVP_Digest_RMD160_loop, loopargs);
1978 print_result(D_RMD160, testnum, count, d);
1982 #ifndef OPENSSL_NO_RC4
1984 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1985 print_message(names[D_RC4], c[D_RC4][testnum], lengths[testnum]);
1987 count = run_benchmark(async_jobs, RC4_loop, loopargs);
1989 print_result(D_RC4, testnum, count, d);
1993 #ifndef OPENSSL_NO_DES
1994 if (doit[D_CBC_DES]) {
1995 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1996 print_message(names[D_CBC_DES], c[D_CBC_DES][testnum], lengths[testnum]);
1998 count = run_benchmark(async_jobs, DES_ncbc_encrypt_loop, loopargs);
2000 print_result(D_CBC_DES, testnum, count, d);
2004 if (doit[D_EDE3_DES]) {
2005 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2006 print_message(names[D_EDE3_DES], c[D_EDE3_DES][testnum], lengths[testnum]);
2008 count = run_benchmark(async_jobs, DES_ede3_cbc_encrypt_loop, loopargs);
2010 print_result(D_EDE3_DES, testnum, count, d);
2015 if (doit[D_CBC_128_AES]) {
2016 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2017 print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][testnum],
2020 count = run_benchmark(async_jobs, AES_cbc_128_encrypt_loop, loopargs);
2022 print_result(D_CBC_128_AES, testnum, count, d);
2025 if (doit[D_CBC_192_AES]) {
2026 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2027 print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][testnum],
2030 count = run_benchmark(async_jobs, AES_cbc_192_encrypt_loop, loopargs);
2032 print_result(D_CBC_192_AES, testnum, count, d);
2035 if (doit[D_CBC_256_AES]) {
2036 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2037 print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][testnum],
2040 count = run_benchmark(async_jobs, AES_cbc_256_encrypt_loop, loopargs);
2042 print_result(D_CBC_256_AES, testnum, count, d);
2046 if (doit[D_IGE_128_AES]) {
2047 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2048 print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][testnum],
2051 count = run_benchmark(async_jobs, AES_ige_128_encrypt_loop, loopargs);
2053 print_result(D_IGE_128_AES, testnum, count, d);
2056 if (doit[D_IGE_192_AES]) {
2057 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2058 print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][testnum],
2061 count = run_benchmark(async_jobs, AES_ige_192_encrypt_loop, loopargs);
2063 print_result(D_IGE_192_AES, testnum, count, d);
2066 if (doit[D_IGE_256_AES]) {
2067 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2068 print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][testnum],
2071 count = run_benchmark(async_jobs, AES_ige_256_encrypt_loop, loopargs);
2073 print_result(D_IGE_256_AES, testnum, count, d);
2076 if (doit[D_GHASH]) {
2077 for (i = 0; i < loopargs_len; i++) {
2078 loopargs[i].gcm_ctx = CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
2079 CRYPTO_gcm128_setiv(loopargs[i].gcm_ctx, (unsigned char *)"0123456789ab", 12);
2082 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2083 print_message(names[D_GHASH], c[D_GHASH][testnum], lengths[testnum]);
2085 count = run_benchmark(async_jobs, CRYPTO_gcm128_aad_loop, loopargs);
2087 print_result(D_GHASH, testnum, count, d);
2089 for (i = 0; i < loopargs_len; i++)
2090 CRYPTO_gcm128_release(loopargs[i].gcm_ctx);
2093 #ifndef OPENSSL_NO_CAMELLIA
2094 if (doit[D_CBC_128_CML]) {
2095 if (async_jobs > 0) {
2096 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2097 names[D_CBC_128_CML]);
2098 doit[D_CBC_128_CML] = 0;
2100 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2101 print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][testnum],
2104 for (count = 0, run = 1; COND(c[D_CBC_128_CML][testnum]); count++)
2105 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2106 (size_t)lengths[testnum], &camellia_ks1,
2107 iv, CAMELLIA_ENCRYPT);
2109 print_result(D_CBC_128_CML, testnum, count, d);
2112 if (doit[D_CBC_192_CML]) {
2113 if (async_jobs > 0) {
2114 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2115 names[D_CBC_192_CML]);
2116 doit[D_CBC_192_CML] = 0;
2118 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2119 print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][testnum],
2121 if (async_jobs > 0) {
2122 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2126 for (count = 0, run = 1; COND(c[D_CBC_192_CML][testnum]); count++)
2127 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2128 (size_t)lengths[testnum], &camellia_ks2,
2129 iv, CAMELLIA_ENCRYPT);
2131 print_result(D_CBC_192_CML, testnum, count, d);
2134 if (doit[D_CBC_256_CML]) {
2135 if (async_jobs > 0) {
2136 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2137 names[D_CBC_256_CML]);
2138 doit[D_CBC_256_CML] = 0;
2140 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2141 print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][testnum],
2144 for (count = 0, run = 1; COND(c[D_CBC_256_CML][testnum]); count++)
2145 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2146 (size_t)lengths[testnum], &camellia_ks3,
2147 iv, CAMELLIA_ENCRYPT);
2149 print_result(D_CBC_256_CML, testnum, count, d);
2153 #ifndef OPENSSL_NO_IDEA
2154 if (doit[D_CBC_IDEA]) {
2155 if (async_jobs > 0) {
2156 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2158 doit[D_CBC_IDEA] = 0;
2160 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2161 print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][testnum], lengths[testnum]);
2163 for (count = 0, run = 1; COND(c[D_CBC_IDEA][testnum]); count++)
2164 IDEA_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2165 (size_t)lengths[testnum], &idea_ks,
2168 print_result(D_CBC_IDEA, testnum, count, d);
2172 #ifndef OPENSSL_NO_SEED
2173 if (doit[D_CBC_SEED]) {
2174 if (async_jobs > 0) {
2175 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2177 doit[D_CBC_SEED] = 0;
2179 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2180 print_message(names[D_CBC_SEED], c[D_CBC_SEED][testnum], lengths[testnum]);
2182 for (count = 0, run = 1; COND(c[D_CBC_SEED][testnum]); count++)
2183 SEED_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2184 (size_t)lengths[testnum], &seed_ks, iv, 1);
2186 print_result(D_CBC_SEED, testnum, count, d);
2190 #ifndef OPENSSL_NO_RC2
2191 if (doit[D_CBC_RC2]) {
2192 if (async_jobs > 0) {
2193 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2195 doit[D_CBC_RC2] = 0;
2197 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2198 print_message(names[D_CBC_RC2], c[D_CBC_RC2][testnum], lengths[testnum]);
2199 if (async_jobs > 0) {
2200 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2204 for (count = 0, run = 1; COND(c[D_CBC_RC2][testnum]); count++)
2205 RC2_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2206 (size_t)lengths[testnum], &rc2_ks,
2209 print_result(D_CBC_RC2, testnum, count, d);
2213 #ifndef OPENSSL_NO_RC5
2214 if (doit[D_CBC_RC5]) {
2215 if (async_jobs > 0) {
2216 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2218 doit[D_CBC_RC5] = 0;
2220 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2221 print_message(names[D_CBC_RC5], c[D_CBC_RC5][testnum], lengths[testnum]);
2222 if (async_jobs > 0) {
2223 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2227 for (count = 0, run = 1; COND(c[D_CBC_RC5][testnum]); count++)
2228 RC5_32_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2229 (size_t)lengths[testnum], &rc5_ks,
2232 print_result(D_CBC_RC5, testnum, count, d);
2236 #ifndef OPENSSL_NO_BF
2237 if (doit[D_CBC_BF]) {
2238 if (async_jobs > 0) {
2239 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2243 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2244 print_message(names[D_CBC_BF], c[D_CBC_BF][testnum], lengths[testnum]);
2246 for (count = 0, run = 1; COND(c[D_CBC_BF][testnum]); count++)
2247 BF_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2248 (size_t)lengths[testnum], &bf_ks,
2251 print_result(D_CBC_BF, testnum, count, d);
2255 #ifndef OPENSSL_NO_CAST
2256 if (doit[D_CBC_CAST]) {
2257 if (async_jobs > 0) {
2258 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2260 doit[D_CBC_CAST] = 0;
2262 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2263 print_message(names[D_CBC_CAST], c[D_CBC_CAST][testnum], lengths[testnum]);
2265 for (count = 0, run = 1; COND(c[D_CBC_CAST][testnum]); count++)
2266 CAST_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2267 (size_t)lengths[testnum], &cast_ks,
2270 print_result(D_CBC_CAST, testnum, count, d);
2276 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
2277 if (multiblock && evp_cipher) {
2279 (EVP_CIPHER_flags(evp_cipher) &
2280 EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
2281 BIO_printf(bio_err, "%s is not multi-block capable\n",
2282 OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
2285 if (async_jobs > 0) {
2286 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2289 multiblock_speed(evp_cipher);
2294 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2297 names[D_EVP] = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
2299 * -O3 -fschedule-insns messes up an optimization here!
2300 * names[D_EVP] somehow becomes NULL
2302 print_message(names[D_EVP], save_count, lengths[testnum]);
2304 for (k = 0; k < loopargs_len; k++) {
2305 loopargs[k].ctx = EVP_CIPHER_CTX_new();
2307 EVP_DecryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2309 EVP_EncryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2310 EVP_CIPHER_CTX_set_padding(loopargs[k].ctx, 0);
2314 count = run_benchmark(async_jobs, EVP_Update_loop, loopargs);
2316 for (k = 0; k < loopargs_len; k++) {
2317 EVP_CIPHER_CTX_free(loopargs[k].ctx);
2321 names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
2322 print_message(names[D_EVP], save_count, lengths[testnum]);
2324 count = run_benchmark(async_jobs, EVP_Digest_loop, loopargs);
2327 print_result(D_EVP, testnum, count, d);
2331 for (i = 0; i < loopargs_len; i++)
2332 RAND_bytes(loopargs[i].buf, 36);
2334 #ifndef OPENSSL_NO_RSA
2335 for (testnum = 0; testnum < RSA_NUM; testnum++) {
2337 if (!rsa_doit[testnum])
2339 for (i = 0; i < loopargs_len; i++) {
2340 st = RSA_sign(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2341 &loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2347 "RSA sign failure. No RSA sign will be done.\n");
2348 ERR_print_errors(bio_err);
2351 pkey_print_message("private", "rsa",
2352 rsa_c[testnum][0], rsa_bits[testnum], RSA_SECONDS);
2353 /* RSA_blinding_on(rsa_key[testnum],NULL); */
2355 count = run_benchmark(async_jobs, RSA_sign_loop, loopargs);
2358 mr ? "+R1:%ld:%d:%.2f\n"
2359 : "%ld %d bit private RSA's in %.2fs\n",
2360 count, rsa_bits[testnum], d);
2361 rsa_results[testnum][0] = d / (double)count;
2365 for (i = 0; i < loopargs_len; i++) {
2366 st = RSA_verify(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2367 loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2373 "RSA verify failure. No RSA verify will be done.\n");
2374 ERR_print_errors(bio_err);
2375 rsa_doit[testnum] = 0;
2377 pkey_print_message("public", "rsa",
2378 rsa_c[testnum][1], rsa_bits[testnum], RSA_SECONDS);
2380 count = run_benchmark(async_jobs, RSA_verify_loop, loopargs);
2383 mr ? "+R2:%ld:%d:%.2f\n"
2384 : "%ld %d bit public RSA's in %.2fs\n",
2385 count, rsa_bits[testnum], d);
2386 rsa_results[testnum][1] = d / (double)count;
2389 if (rsa_count <= 1) {
2390 /* if longer than 10s, don't do any more */
2391 for (testnum++; testnum < RSA_NUM; testnum++)
2392 rsa_doit[testnum] = 0;
2395 #endif /* OPENSSL_NO_RSA */
2397 for (i = 0; i < loopargs_len; i++)
2398 RAND_bytes(loopargs[i].buf, 36);
2400 #ifndef OPENSSL_NO_DSA
2401 if (RAND_status() != 1) {
2402 RAND_seed(rnd_seed, sizeof rnd_seed);
2404 for (testnum = 0; testnum < DSA_NUM; testnum++) {
2406 if (!dsa_doit[testnum])
2409 /* DSA_generate_key(dsa_key[testnum]); */
2410 /* DSA_sign_setup(dsa_key[testnum],NULL); */
2411 for (i = 0; i < loopargs_len; i++) {
2412 st = DSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2413 &loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2419 "DSA sign failure. No DSA sign will be done.\n");
2420 ERR_print_errors(bio_err);
2423 pkey_print_message("sign", "dsa",
2424 dsa_c[testnum][0], dsa_bits[testnum], DSA_SECONDS);
2426 count = run_benchmark(async_jobs, DSA_sign_loop, loopargs);
2429 mr ? "+R3:%ld:%d:%.2f\n"
2430 : "%ld %d bit DSA signs in %.2fs\n",
2431 count, dsa_bits[testnum], d);
2432 dsa_results[testnum][0] = d / (double)count;
2436 for (i = 0; i < loopargs_len; i++) {
2437 st = DSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2438 loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2444 "DSA verify failure. No DSA verify will be done.\n");
2445 ERR_print_errors(bio_err);
2446 dsa_doit[testnum] = 0;
2448 pkey_print_message("verify", "dsa",
2449 dsa_c[testnum][1], dsa_bits[testnum], DSA_SECONDS);
2451 count = run_benchmark(async_jobs, DSA_verify_loop, loopargs);
2454 mr ? "+R4:%ld:%d:%.2f\n"
2455 : "%ld %d bit DSA verify in %.2fs\n",
2456 count, dsa_bits[testnum], d);
2457 dsa_results[testnum][1] = d / (double)count;
2460 if (rsa_count <= 1) {
2461 /* if longer than 10s, don't do any more */
2462 for (testnum++; testnum < DSA_NUM; testnum++)
2463 dsa_doit[testnum] = 0;
2466 #endif /* OPENSSL_NO_DSA */
2468 #ifndef OPENSSL_NO_EC
2469 if (RAND_status() != 1) {
2470 RAND_seed(rnd_seed, sizeof rnd_seed);
2472 for (testnum = 0; testnum < EC_NUM; testnum++) {
2475 if (!ecdsa_doit[testnum])
2476 continue; /* Ignore Curve */
2477 for (i = 0; i < loopargs_len; i++) {
2478 loopargs[i].ecdsa[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2479 if (loopargs[i].ecdsa[testnum] == NULL) {
2485 BIO_printf(bio_err, "ECDSA failure.\n");
2486 ERR_print_errors(bio_err);
2489 for (i = 0; i < loopargs_len; i++) {
2490 EC_KEY_precompute_mult(loopargs[i].ecdsa[testnum], NULL);
2491 /* Perform ECDSA signature test */
2492 EC_KEY_generate_key(loopargs[i].ecdsa[testnum]);
2493 st = ECDSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2494 &loopargs[i].siglen, loopargs[i].ecdsa[testnum]);
2500 "ECDSA sign failure. No ECDSA sign will be done.\n");
2501 ERR_print_errors(bio_err);
2504 pkey_print_message("sign", "ecdsa",
2505 ecdsa_c[testnum][0],
2506 test_curves_bits[testnum], ECDSA_SECONDS);
2508 count = run_benchmark(async_jobs, ECDSA_sign_loop, loopargs);
2512 mr ? "+R5:%ld:%d:%.2f\n" :
2513 "%ld %d bit ECDSA signs in %.2fs \n",
2514 count, test_curves_bits[testnum], d);
2515 ecdsa_results[testnum][0] = d / (double)count;
2519 /* Perform ECDSA verification test */
2520 for (i = 0; i < loopargs_len; i++) {
2521 st = ECDSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2522 loopargs[i].siglen, loopargs[i].ecdsa[testnum]);
2528 "ECDSA verify failure. No ECDSA verify will be done.\n");
2529 ERR_print_errors(bio_err);
2530 ecdsa_doit[testnum] = 0;
2532 pkey_print_message("verify", "ecdsa",
2533 ecdsa_c[testnum][1],
2534 test_curves_bits[testnum], ECDSA_SECONDS);
2536 count = run_benchmark(async_jobs, ECDSA_verify_loop, loopargs);
2539 mr ? "+R6:%ld:%d:%.2f\n"
2540 : "%ld %d bit ECDSA verify in %.2fs\n",
2541 count, test_curves_bits[testnum], d);
2542 ecdsa_results[testnum][1] = d / (double)count;
2545 if (rsa_count <= 1) {
2546 /* if longer than 10s, don't do any more */
2547 for (testnum++; testnum < EC_NUM; testnum++)
2548 ecdsa_doit[testnum] = 0;
2553 if (RAND_status() != 1) {
2554 RAND_seed(rnd_seed, sizeof rnd_seed);
2556 for (testnum = 0; testnum < EC_NUM; testnum++) {
2557 int ecdh_checks = 1;
2559 if (!ecdh_doit[testnum])
2561 for (i = 0; i < loopargs_len; i++) {
2562 loopargs[i].ecdh_a[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2563 loopargs[i].ecdh_b[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2564 if (loopargs[i].ecdh_a[testnum] == NULL ||
2565 loopargs[i].ecdh_b[testnum] == NULL) {
2570 if (ecdh_checks == 0) {
2571 BIO_printf(bio_err, "ECDH failure.\n");
2572 ERR_print_errors(bio_err);
2575 for (i = 0; i < loopargs_len; i++) {
2576 /* generate two ECDH key pairs */
2577 if (!EC_KEY_generate_key(loopargs[i].ecdh_a[testnum]) ||
2578 !EC_KEY_generate_key(loopargs[i].ecdh_b[testnum])) {
2579 BIO_printf(bio_err, "ECDH key generation failure.\n");
2580 ERR_print_errors(bio_err);
2584 int secret_size_a, secret_size_b;
2586 * If field size is not more than 24 octets, then use SHA-1
2587 * hash of result; otherwise, use result (see section 4.8 of
2588 * draft-ietf-tls-ecc-03.txt).
2590 int field_size = EC_GROUP_get_degree(
2591 EC_KEY_get0_group(loopargs[i].ecdh_a[testnum]));
2593 if (field_size <= 24 * 8) { /* 192 bits */
2594 loopargs[i].outlen = KDF1_SHA1_len;
2595 loopargs[i].kdf = KDF1_SHA1;
2597 loopargs[i].outlen = (field_size + 7) / 8;
2598 loopargs[i].kdf = NULL;
2601 ECDH_compute_key(loopargs[i].secret_a, loopargs[i].outlen,
2602 EC_KEY_get0_public_key(loopargs[i].ecdh_b[testnum]),
2603 loopargs[i].ecdh_a[testnum], loopargs[i].kdf);
2605 ECDH_compute_key(loopargs[i].secret_b, loopargs[i].outlen,
2606 EC_KEY_get0_public_key(loopargs[i].ecdh_a[testnum]),
2607 loopargs[i].ecdh_b[testnum], loopargs[i].kdf);
2608 if (secret_size_a != secret_size_b)
2613 for (k = 0; k < secret_size_a && ecdh_checks == 1; k++) {
2614 if (loopargs[i].secret_a[k] != loopargs[i].secret_b[k])
2618 if (ecdh_checks == 0) {
2619 BIO_printf(bio_err, "ECDH computations don't match.\n");
2620 ERR_print_errors(bio_err);
2626 if (ecdh_checks != 0) {
2627 pkey_print_message("", "ecdh",
2629 test_curves_bits[testnum], ECDH_SECONDS);
2631 count = run_benchmark(async_jobs, ECDH_compute_key_loop, loopargs);
2634 mr ? "+R7:%ld:%d:%.2f\n" :
2635 "%ld %d-bit ECDH ops in %.2fs\n", count,
2636 test_curves_bits[testnum], d);
2637 ecdh_results[testnum][0] = d / (double)count;
2642 if (rsa_count <= 1) {
2643 /* if longer than 10s, don't do any more */
2644 for (testnum++; testnum < EC_NUM; testnum++)
2645 ecdh_doit[testnum] = 0;
2648 #endif /* OPENSSL_NO_EC */
2653 printf("%s\n", OpenSSL_version(OPENSSL_VERSION));
2654 printf("%s\n", OpenSSL_version(OPENSSL_BUILT_ON));
2656 printf("%s ", BN_options());
2657 #ifndef OPENSSL_NO_MD2
2658 printf("%s ", MD2_options());
2660 #ifndef OPENSSL_NO_RC4
2661 printf("%s ", RC4_options());
2663 #ifndef OPENSSL_NO_DES
2664 printf("%s ", DES_options());
2666 printf("%s ", AES_options());
2667 #ifndef OPENSSL_NO_IDEA
2668 printf("%s ", IDEA_options());
2670 #ifndef OPENSSL_NO_BF
2671 printf("%s ", BF_options());
2673 printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
2681 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2684 for (testnum = 0; testnum < SIZE_NUM; testnum++)
2685 printf(mr ? ":%d" : "%7d bytes", lengths[testnum]);
2689 for (k = 0; k < ALGOR_NUM; k++) {
2693 printf("+F:%d:%s", k, names[k]);
2695 printf("%-13s", names[k]);
2696 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2697 if (results[k][testnum] > 10000 && !mr)
2698 printf(" %11.2fk", results[k][testnum] / 1e3);
2700 printf(mr ? ":%.2f" : " %11.2f ", results[k][testnum]);
2704 #ifndef OPENSSL_NO_RSA
2706 for (k = 0; k < RSA_NUM; k++) {
2709 if (testnum && !mr) {
2710 printf("%18ssign verify sign/s verify/s\n", " ");
2714 printf("+F2:%u:%u:%f:%f\n",
2715 k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2717 printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2718 rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2719 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2722 #ifndef OPENSSL_NO_DSA
2724 for (k = 0; k < DSA_NUM; k++) {
2727 if (testnum && !mr) {
2728 printf("%18ssign verify sign/s verify/s\n", " ");
2732 printf("+F3:%u:%u:%f:%f\n",
2733 k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2735 printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2736 dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2737 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2740 #ifndef OPENSSL_NO_EC
2742 for (k = 0; k < EC_NUM; k++) {
2745 if (testnum && !mr) {
2746 printf("%30ssign verify sign/s verify/s\n", " ");
2751 printf("+F4:%u:%u:%f:%f\n",
2752 k, test_curves_bits[k],
2753 ecdsa_results[k][0], ecdsa_results[k][1]);
2755 printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2756 test_curves_bits[k],
2757 test_curves_names[k],
2758 ecdsa_results[k][0], ecdsa_results[k][1],
2759 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2763 for (k = 0; k < EC_NUM; k++) {
2766 if (testnum && !mr) {
2767 printf("%30sop op/s\n", " ");
2771 printf("+F5:%u:%u:%f:%f\n",
2772 k, test_curves_bits[k],
2773 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2776 printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2777 test_curves_bits[k],
2778 test_curves_names[k],
2779 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2786 ERR_print_errors(bio_err);
2787 for (i = 0; i < loopargs_len; i++) {
2788 OPENSSL_free(loopargs[i].buf_malloc);
2789 OPENSSL_free(loopargs[i].buf2_malloc);
2791 #ifndef OPENSSL_NO_RSA
2792 for (k = 0; k < RSA_NUM; k++)
2793 RSA_free(loopargs[i].rsa_key[k]);
2795 #ifndef OPENSSL_NO_DSA
2796 for (k = 0; k < DSA_NUM; k++)
2797 DSA_free(loopargs[i].dsa_key[k]);
2799 #ifndef OPENSSL_NO_EC
2800 for (k = 0; k < EC_NUM; k++) {
2801 EC_KEY_free(loopargs[i].ecdsa[k]);
2802 EC_KEY_free(loopargs[i].ecdh_a[k]);
2803 EC_KEY_free(loopargs[i].ecdh_b[k]);
2805 OPENSSL_free(loopargs[i].secret_a);
2806 OPENSSL_free(loopargs[i].secret_b);
2810 if (async_jobs > 0) {
2811 for (i = 0; i < loopargs_len; i++)
2812 ASYNC_WAIT_CTX_free(loopargs[i].wait_ctx);
2816 ASYNC_cleanup_thread();
2818 OPENSSL_free(loopargs);
2823 static void print_message(const char *s, long num, int length)
2827 mr ? "+DT:%s:%d:%d\n"
2828 : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2829 (void)BIO_flush(bio_err);
2833 mr ? "+DN:%s:%ld:%d\n"
2834 : "Doing %s %ld times on %d size blocks: ", s, num, length);
2835 (void)BIO_flush(bio_err);
2839 static void pkey_print_message(const char *str, const char *str2, long num,
2844 mr ? "+DTP:%d:%s:%s:%d\n"
2845 : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2846 (void)BIO_flush(bio_err);
2850 mr ? "+DNP:%ld:%d:%s:%s\n"
2851 : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2852 (void)BIO_flush(bio_err);
2856 static void print_result(int alg, int run_no, int count, double time_used)
2859 BIO_puts(bio_err, "EVP error!\n");
2863 mr ? "+R:%d:%s:%f\n"
2864 : "%d %s's in %.2fs\n", count, names[alg], time_used);
2865 results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2869 static char *sstrsep(char **string, const char *delim)
2872 char *token = *string;
2877 memset(isdelim, 0, sizeof isdelim);
2881 isdelim[(unsigned char)(*delim)] = 1;
2885 while (!isdelim[(unsigned char)(**string)]) {
2897 static int do_multi(int multi)
2902 static char sep[] = ":";
2904 fds = malloc(sizeof(*fds) * multi);
2905 for (n = 0; n < multi; ++n) {
2906 if (pipe(fd) == -1) {
2907 BIO_printf(bio_err, "pipe failure\n");
2911 (void)BIO_flush(bio_err);
2918 if (dup(fd[1]) == -1) {
2919 BIO_printf(bio_err, "dup failed\n");
2928 printf("Forked child %d\n", n);
2931 /* for now, assume the pipe is long enough to take all the output */
2932 for (n = 0; n < multi; ++n) {
2937 f = fdopen(fds[n], "r");
2938 while (fgets(buf, sizeof buf, f)) {
2939 p = strchr(buf, '\n');
2942 if (buf[0] != '+') {
2943 BIO_printf(bio_err, "Don't understand line '%s' from child %d\n",
2947 printf("Got: %s from %d\n", buf, n);
2948 if (strncmp(buf, "+F:", 3) == 0) {
2953 alg = atoi(sstrsep(&p, sep));
2955 for (j = 0; j < SIZE_NUM; ++j)
2956 results[alg][j] += atof(sstrsep(&p, sep));
2957 } else if (strncmp(buf, "+F2:", 4) == 0) {
2962 k = atoi(sstrsep(&p, sep));
2965 d = atof(sstrsep(&p, sep));
2967 rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
2969 rsa_results[k][0] = d;
2971 d = atof(sstrsep(&p, sep));
2973 rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
2975 rsa_results[k][1] = d;
2977 # ifndef OPENSSL_NO_DSA
2978 else if (strncmp(buf, "+F3:", 4) == 0) {
2983 k = atoi(sstrsep(&p, sep));
2986 d = atof(sstrsep(&p, sep));
2988 dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
2990 dsa_results[k][0] = d;
2992 d = atof(sstrsep(&p, sep));
2994 dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
2996 dsa_results[k][1] = d;
2999 # ifndef OPENSSL_NO_EC
3000 else if (strncmp(buf, "+F4:", 4) == 0) {
3005 k = atoi(sstrsep(&p, sep));
3008 d = atof(sstrsep(&p, sep));
3010 ecdsa_results[k][0] =
3011 1 / (1 / ecdsa_results[k][0] + 1 / d);
3013 ecdsa_results[k][0] = d;
3015 d = atof(sstrsep(&p, sep));
3017 ecdsa_results[k][1] =
3018 1 / (1 / ecdsa_results[k][1] + 1 / d);
3020 ecdsa_results[k][1] = d;
3021 } else if (strncmp(buf, "+F5:", 4) == 0) {
3026 k = atoi(sstrsep(&p, sep));
3029 d = atof(sstrsep(&p, sep));
3031 ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
3033 ecdh_results[k][0] = d;
3038 else if (strncmp(buf, "+H:", 3) == 0) {
3041 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf, n);
3051 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
3053 static int mblengths[] =
3054 { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
3055 int j, count, num = OSSL_NELEM(mblengths);
3056 const char *alg_name;
3057 unsigned char *inp, *out, no_key[32], no_iv[16];
3058 EVP_CIPHER_CTX *ctx;
3061 inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
3062 out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
3063 ctx = EVP_CIPHER_CTX_new();
3064 EVP_EncryptInit_ex(ctx, evp_cipher, NULL, no_key, no_iv);
3065 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key),
3067 alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
3069 for (j = 0; j < num; j++) {
3070 print_message(alg_name, 0, mblengths[j]);
3072 for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
3073 unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
3074 EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
3075 size_t len = mblengths[j];
3078 memset(aad, 0, 8); /* avoid uninitialized values */
3079 aad[8] = 23; /* SSL3_RT_APPLICATION_DATA */
3080 aad[9] = 3; /* version */
3082 aad[11] = 0; /* length */
3084 mb_param.out = NULL;
3087 mb_param.interleave = 8;
3089 packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
3090 sizeof(mb_param), &mb_param);
3096 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
3097 sizeof(mb_param), &mb_param);
3101 RAND_bytes(out, 16);
3105 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
3106 EVP_AEAD_TLS1_AAD_LEN, aad);
3107 EVP_Cipher(ctx, out, inp, len + pad);
3111 BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
3112 : "%d %s's in %.2fs\n", count, "evp", d);
3113 results[D_EVP][j] = ((double)count) / d * mblengths[j];
3117 fprintf(stdout, "+H");
3118 for (j = 0; j < num; j++)
3119 fprintf(stdout, ":%d", mblengths[j]);
3120 fprintf(stdout, "\n");
3121 fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
3122 for (j = 0; j < num; j++)
3123 fprintf(stdout, ":%.2f", results[D_EVP][j]);
3124 fprintf(stdout, "\n");
3127 "The 'numbers' are in 1000s of bytes per second processed.\n");
3128 fprintf(stdout, "type ");
3129 for (j = 0; j < num; j++)
3130 fprintf(stdout, "%7d bytes", mblengths[j]);
3131 fprintf(stdout, "\n");
3132 fprintf(stdout, "%-24s", alg_name);
3134 for (j = 0; j < num; j++) {
3135 if (results[D_EVP][j] > 10000)
3136 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
3138 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
3140 fprintf(stdout, "\n");
3145 EVP_CIPHER_CTX_free(ctx);