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)
1222 loopargs_t *loopargs = NULL;
1224 int loopargs_len = 0;
1226 #ifndef OPENSSL_NO_ENGINE
1227 const char *engine_id = NULL;
1229 const EVP_CIPHER *evp_cipher = NULL;
1232 int multiblock = 0, pr_header = 0;
1233 int doit[ALGOR_NUM] = { 0 };
1234 int ret = 1, i, k, misalign = 0;
1240 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) \
1241 || !defined(OPENSSL_NO_EC)
1245 /* What follows are the buffers and key material. */
1246 #ifndef OPENSSL_NO_RC5
1249 #ifndef OPENSSL_NO_RC2
1252 #ifndef OPENSSL_NO_IDEA
1253 IDEA_KEY_SCHEDULE idea_ks;
1255 #ifndef OPENSSL_NO_SEED
1256 SEED_KEY_SCHEDULE seed_ks;
1258 #ifndef OPENSSL_NO_BF
1261 #ifndef OPENSSL_NO_CAST
1264 static const unsigned char key16[16] = {
1265 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1266 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1268 static const unsigned char key24[24] = {
1269 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1270 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1271 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1273 static const unsigned char key32[32] = {
1274 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1275 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1276 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1277 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1279 #ifndef OPENSSL_NO_CAMELLIA
1280 static const unsigned char ckey24[24] = {
1281 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1282 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1283 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1285 static const unsigned char ckey32[32] = {
1286 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1287 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1288 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1289 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1291 CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
1293 #ifndef OPENSSL_NO_DES
1294 static DES_cblock key = {
1295 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
1297 static DES_cblock key2 = {
1298 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1300 static DES_cblock key3 = {
1301 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1304 #ifndef OPENSSL_NO_RSA
1305 static const unsigned int rsa_bits[RSA_NUM] = {
1306 512, 1024, 2048, 3072, 4096, 7680, 15360
1308 static const unsigned char *rsa_data[RSA_NUM] = {
1309 test512, test1024, test2048, test3072, test4096, test7680, test15360
1311 static const int rsa_data_length[RSA_NUM] = {
1312 sizeof(test512), sizeof(test1024),
1313 sizeof(test2048), sizeof(test3072),
1314 sizeof(test4096), sizeof(test7680),
1317 int rsa_doit[RSA_NUM] = { 0 };
1319 #ifndef OPENSSL_NO_DSA
1320 static const unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
1321 int dsa_doit[DSA_NUM] = { 0 };
1323 #ifndef OPENSSL_NO_EC
1325 * We only test over the following curves as they are representative, To
1326 * add tests over more curves, simply add the curve NID and curve name to
1327 * the following arrays and increase the EC_NUM value accordingly.
1329 static const unsigned int test_curves[EC_NUM] = {
1331 NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
1332 NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
1334 NID_sect163k1, NID_sect233k1, NID_sect283k1,
1335 NID_sect409k1, NID_sect571k1, NID_sect163r2,
1336 NID_sect233r1, NID_sect283r1, NID_sect409r1,
1341 static const char *test_curves_names[EC_NUM] = {
1343 "secp160r1", "nistp192", "nistp224",
1344 "nistp256", "nistp384", "nistp521",
1346 "nistk163", "nistk233", "nistk283",
1347 "nistk409", "nistk571", "nistb163",
1348 "nistb233", "nistb283", "nistb409",
1353 static const int test_curves_bits[EC_NUM] = {
1359 571, 253 /* X25519 */
1362 int ecdsa_doit[EC_NUM] = { 0 };
1363 int ecdh_doit[EC_NUM] = { 0 };
1364 #endif /* ndef OPENSSL_NO_EC */
1366 prog = opt_init(argc, argv, speed_options);
1367 while ((o = opt_next()) != OPT_EOF) {
1372 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
1375 opt_help(speed_options);
1382 evp_cipher = EVP_get_cipherbyname(opt_arg());
1383 if (evp_cipher == NULL)
1384 evp_md = EVP_get_digestbyname(opt_arg());
1385 if (evp_cipher == NULL && evp_md == NULL) {
1387 "%s: %s is an unknown cipher or digest\n",
1398 * In a forked execution, an engine might need to be
1399 * initialised by each child process, not by the parent.
1400 * So store the name here and run setup_engine() later on.
1402 #ifndef OPENSSL_NO_ENGINE
1403 engine_id = opt_arg();
1408 multi = atoi(opt_arg());
1412 #ifndef OPENSSL_NO_ASYNC
1413 async_jobs = atoi(opt_arg());
1414 if (!ASYNC_is_capable()) {
1416 "%s: async_jobs specified but async not supported\n",
1423 if (!opt_int(opt_arg(), &misalign))
1425 if (misalign > MISALIGN) {
1427 "%s: Maximum offset is %d\n", prog, MISALIGN);
1436 #ifdef OPENSSL_NO_MULTIBLOCK
1438 "%s: -mb specified but multi-block support is disabled\n",
1445 argc = opt_num_rest();
1448 /* Remaining arguments are algorithms. */
1449 for ( ; *argv; argv++) {
1450 if (found(*argv, doit_choices, &i)) {
1454 #ifndef OPENSSL_NO_DES
1455 if (strcmp(*argv, "des") == 0) {
1456 doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
1460 if (strcmp(*argv, "sha") == 0) {
1461 doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
1464 #ifndef OPENSSL_NO_RSA
1466 if (strcmp(*argv, "openssl") == 0) {
1467 RSA_set_default_method(RSA_PKCS1_OpenSSL());
1471 if (strcmp(*argv, "rsa") == 0) {
1472 rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
1473 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
1474 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
1475 rsa_doit[R_RSA_15360] = 1;
1478 if (found(*argv, rsa_choices, &i)) {
1483 #ifndef OPENSSL_NO_DSA
1484 if (strcmp(*argv, "dsa") == 0) {
1485 dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
1486 dsa_doit[R_DSA_2048] = 1;
1489 if (found(*argv, dsa_choices, &i)) {
1494 if (strcmp(*argv, "aes") == 0) {
1495 doit[D_CBC_128_AES] = doit[D_CBC_192_AES] =
1496 doit[D_CBC_256_AES] = 1;
1499 #ifndef OPENSSL_NO_CAMELLIA
1500 if (strcmp(*argv, "camellia") == 0) {
1501 doit[D_CBC_128_CML] = doit[D_CBC_192_CML] =
1502 doit[D_CBC_256_CML] = 1;
1506 #ifndef OPENSSL_NO_EC
1507 if (strcmp(*argv, "ecdsa") == 0) {
1508 for (i = 0; i < EC_NUM; i++)
1512 if (found(*argv, ecdsa_choices, &i)) {
1516 if (strcmp(*argv, "ecdh") == 0) {
1517 for (i = 0; i < EC_NUM; i++)
1521 if (found(*argv, ecdh_choices, &i)) {
1526 BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
1530 /* Initialize the job pool if async mode is enabled */
1531 if (async_jobs > 0) {
1532 async_init = ASYNC_init_thread(async_jobs, async_jobs);
1534 BIO_printf(bio_err, "Error creating the ASYNC job pool\n");
1539 loopargs_len = (async_jobs == 0 ? 1 : async_jobs);
1540 loopargs = app_malloc(loopargs_len * sizeof(loopargs_t), "array of loopargs");
1541 memset(loopargs, 0, loopargs_len * sizeof(loopargs_t));
1543 for (i = 0; i < loopargs_len; i++) {
1544 if (async_jobs > 0) {
1545 loopargs[i].wait_ctx = ASYNC_WAIT_CTX_new();
1546 if (loopargs[i].wait_ctx == NULL) {
1547 BIO_printf(bio_err, "Error creating the ASYNC_WAIT_CTX\n");
1552 loopargs[i].buf_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1553 loopargs[i].buf2_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1554 /* Align the start of buffers on a 64 byte boundary */
1555 loopargs[i].buf = loopargs[i].buf_malloc + misalign;
1556 loopargs[i].buf2 = loopargs[i].buf2_malloc + misalign;
1557 #ifndef OPENSSL_NO_EC
1558 loopargs[i].secret_a = app_malloc(MAX_ECDH_SIZE, "ECDH secret a");
1559 loopargs[i].secret_b = app_malloc(MAX_ECDH_SIZE, "ECDH secret b");
1564 if (multi && do_multi(multi))
1568 /* Initialize the engine after the fork */
1569 (void)setup_engine(engine_id, 0);
1571 /* No parameters; turn on everything. */
1572 if ((argc == 0) && !doit[D_EVP]) {
1573 for (i = 0; i < ALGOR_NUM; i++)
1576 #ifndef OPENSSL_NO_RSA
1577 for (i = 0; i < RSA_NUM; i++)
1580 #ifndef OPENSSL_NO_DSA
1581 for (i = 0; i < DSA_NUM; i++)
1584 #ifndef OPENSSL_NO_EC
1585 for (i = 0; i < EC_NUM; i++)
1587 for (i = 0; i < EC_NUM; i++)
1591 for (i = 0; i < ALGOR_NUM; i++)
1595 if (usertime == 0 && !mr)
1597 "You have chosen to measure elapsed time "
1598 "instead of user CPU time.\n");
1600 #ifndef OPENSSL_NO_RSA
1601 for (i = 0; i < loopargs_len; i++) {
1602 for (k = 0; k < RSA_NUM; k++) {
1603 const unsigned char *p;
1606 loopargs[i].rsa_key[k] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[k]);
1607 if (loopargs[i].rsa_key[k] == NULL) {
1608 BIO_printf(bio_err, "internal error loading RSA key number %d\n",
1615 #ifndef OPENSSL_NO_DSA
1616 for (i = 0; i < loopargs_len; i++) {
1617 loopargs[i].dsa_key[0] = get_dsa512();
1618 loopargs[i].dsa_key[1] = get_dsa1024();
1619 loopargs[i].dsa_key[2] = get_dsa2048();
1622 #ifndef OPENSSL_NO_DES
1623 DES_set_key_unchecked(&key, &sch);
1624 DES_set_key_unchecked(&key2, &sch2);
1625 DES_set_key_unchecked(&key3, &sch3);
1627 AES_set_encrypt_key(key16, 128, &aes_ks1);
1628 AES_set_encrypt_key(key24, 192, &aes_ks2);
1629 AES_set_encrypt_key(key32, 256, &aes_ks3);
1630 #ifndef OPENSSL_NO_CAMELLIA
1631 Camellia_set_key(key16, 128, &camellia_ks1);
1632 Camellia_set_key(ckey24, 192, &camellia_ks2);
1633 Camellia_set_key(ckey32, 256, &camellia_ks3);
1635 #ifndef OPENSSL_NO_IDEA
1636 IDEA_set_encrypt_key(key16, &idea_ks);
1638 #ifndef OPENSSL_NO_SEED
1639 SEED_set_key(key16, &seed_ks);
1641 #ifndef OPENSSL_NO_RC4
1642 RC4_set_key(&rc4_ks, 16, key16);
1644 #ifndef OPENSSL_NO_RC2
1645 RC2_set_key(&rc2_ks, 16, key16, 128);
1647 #ifndef OPENSSL_NO_RC5
1648 RC5_32_set_key(&rc5_ks, 16, key16, 12);
1650 #ifndef OPENSSL_NO_BF
1651 BF_set_key(&bf_ks, 16, key16);
1653 #ifndef OPENSSL_NO_CAST
1654 CAST_set_key(&cast_ks, 16, key16);
1657 # ifndef OPENSSL_NO_DES
1658 BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1664 for (it = count; it; it--)
1665 DES_ecb_encrypt((DES_cblock *)loopargs[0].buf,
1666 (DES_cblock *)loopargs[0].buf, &sch, DES_ENCRYPT);
1670 c[D_MD2][0] = count / 10;
1671 c[D_MDC2][0] = count / 10;
1672 c[D_MD4][0] = count;
1673 c[D_MD5][0] = count;
1674 c[D_HMAC][0] = count;
1675 c[D_SHA1][0] = count;
1676 c[D_RMD160][0] = count;
1677 c[D_RC4][0] = count * 5;
1678 c[D_CBC_DES][0] = count;
1679 c[D_EDE3_DES][0] = count / 3;
1680 c[D_CBC_IDEA][0] = count;
1681 c[D_CBC_SEED][0] = count;
1682 c[D_CBC_RC2][0] = count;
1683 c[D_CBC_RC5][0] = count;
1684 c[D_CBC_BF][0] = count;
1685 c[D_CBC_CAST][0] = count;
1686 c[D_CBC_128_AES][0] = count;
1687 c[D_CBC_192_AES][0] = count;
1688 c[D_CBC_256_AES][0] = count;
1689 c[D_CBC_128_CML][0] = count;
1690 c[D_CBC_192_CML][0] = count;
1691 c[D_CBC_256_CML][0] = count;
1692 c[D_SHA256][0] = count;
1693 c[D_SHA512][0] = count;
1694 c[D_WHIRLPOOL][0] = count;
1695 c[D_IGE_128_AES][0] = count;
1696 c[D_IGE_192_AES][0] = count;
1697 c[D_IGE_256_AES][0] = count;
1698 c[D_GHASH][0] = count;
1700 for (i = 1; i < SIZE_NUM; i++) {
1703 l0 = (long)lengths[0];
1704 l1 = (long)lengths[i];
1706 c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1707 c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1708 c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1709 c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1710 c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1711 c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1712 c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1713 c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1714 c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1715 c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1716 c[D_GHASH][i] = c[D_GHASH][0] * 4 * l0 / l1;
1718 l0 = (long)lengths[i - 1];
1720 c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1721 c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1722 c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1723 c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1724 c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1725 c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1726 c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1727 c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1728 c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1729 c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1730 c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1731 c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1732 c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1733 c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1734 c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1735 c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1736 c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1737 c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1740 # ifndef OPENSSL_NO_RSA
1741 rsa_c[R_RSA_512][0] = count / 2000;
1742 rsa_c[R_RSA_512][1] = count / 400;
1743 for (i = 1; i < RSA_NUM; i++) {
1744 rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1745 rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1746 if (rsa_doit[i] <= 1 && rsa_c[i][0] == 0)
1749 if (rsa_c[i][0] == 0) {
1750 rsa_c[i][0] = 1; /* Set minimum iteration Nb to 1. */
1757 # ifndef OPENSSL_NO_DSA
1758 dsa_c[R_DSA_512][0] = count / 1000;
1759 dsa_c[R_DSA_512][1] = count / 1000 / 2;
1760 for (i = 1; i < DSA_NUM; i++) {
1761 dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1762 dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1763 if (dsa_doit[i] <= 1 && dsa_c[i][0] == 0)
1766 if (dsa_c[i][0] == 0) {
1767 dsa_c[i][0] = 1; /* Set minimum iteration Nb to 1. */
1774 # ifndef OPENSSL_NO_EC
1775 ecdsa_c[R_EC_P160][0] = count / 1000;
1776 ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1777 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1778 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1779 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1780 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1783 if (ecdsa_c[i][0] == 0) {
1789 ecdsa_c[R_EC_K163][0] = count / 1000;
1790 ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1791 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1792 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1793 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1794 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1797 if (ecdsa_c[i][0] == 0) {
1803 ecdsa_c[R_EC_B163][0] = count / 1000;
1804 ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1805 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1806 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1807 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1808 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1811 if (ecdsa_c[i][0] == 0) {
1818 ecdh_c[R_EC_P160][0] = count / 1000;
1819 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1820 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1821 if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1824 if (ecdh_c[i][0] == 0) {
1829 ecdh_c[R_EC_K163][0] = count / 1000;
1830 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1831 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1832 if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1835 if (ecdh_c[i][0] == 0) {
1840 ecdh_c[R_EC_B163][0] = count / 1000;
1841 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1842 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1843 if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1846 if (ecdh_c[i][0] == 0) {
1854 /* not worth fixing */
1855 # error "You cannot disable DES on systems without SIGALRM."
1856 # endif /* OPENSSL_NO_DES */
1859 signal(SIGALRM, sig_done);
1861 #endif /* SIGALRM */
1863 #ifndef OPENSSL_NO_MD2
1865 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1866 print_message(names[D_MD2], c[D_MD2][testnum], lengths[testnum]);
1868 count = run_benchmark(async_jobs, EVP_Digest_MD2_loop, loopargs);
1870 print_result(D_MD2, testnum, count, d);
1874 #ifndef OPENSSL_NO_MDC2
1876 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1877 print_message(names[D_MDC2], c[D_MDC2][testnum], lengths[testnum]);
1879 count = run_benchmark(async_jobs, EVP_Digest_MDC2_loop, loopargs);
1881 print_result(D_MDC2, testnum, count, d);
1886 #ifndef OPENSSL_NO_MD4
1888 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1889 print_message(names[D_MD4], c[D_MD4][testnum], lengths[testnum]);
1891 count = run_benchmark(async_jobs, EVP_Digest_MD4_loop, loopargs);
1893 print_result(D_MD4, testnum, count, d);
1898 #ifndef OPENSSL_NO_MD5
1900 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1901 print_message(names[D_MD5], c[D_MD5][testnum], lengths[testnum]);
1903 count = run_benchmark(async_jobs, MD5_loop, loopargs);
1905 print_result(D_MD5, testnum, count, d);
1910 static const char hmac_key[] = "This is a key...";
1911 int len = strlen(hmac_key);
1913 for (i = 0; i < loopargs_len; i++) {
1914 loopargs[i].hctx = HMAC_CTX_new();
1915 if (loopargs[i].hctx == NULL) {
1916 BIO_printf(bio_err, "HMAC malloc failure, exiting...");
1920 HMAC_Init_ex(loopargs[i].hctx, hmac_key, len, EVP_md5(), NULL);
1922 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1923 print_message(names[D_HMAC], c[D_HMAC][testnum], lengths[testnum]);
1925 count = run_benchmark(async_jobs, HMAC_loop, loopargs);
1927 print_result(D_HMAC, testnum, count, d);
1929 for (i = 0; i < loopargs_len; i++) {
1930 HMAC_CTX_free(loopargs[i].hctx);
1935 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1936 print_message(names[D_SHA1], c[D_SHA1][testnum], lengths[testnum]);
1938 count = run_benchmark(async_jobs, SHA1_loop, loopargs);
1940 print_result(D_SHA1, testnum, count, d);
1943 if (doit[D_SHA256]) {
1944 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1945 print_message(names[D_SHA256], c[D_SHA256][testnum], lengths[testnum]);
1947 count = run_benchmark(async_jobs, SHA256_loop, loopargs);
1949 print_result(D_SHA256, testnum, count, d);
1952 if (doit[D_SHA512]) {
1953 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1954 print_message(names[D_SHA512], c[D_SHA512][testnum], lengths[testnum]);
1956 count = run_benchmark(async_jobs, SHA512_loop, loopargs);
1958 print_result(D_SHA512, testnum, count, d);
1962 #ifndef OPENSSL_NO_WHIRLPOOL
1963 if (doit[D_WHIRLPOOL]) {
1964 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1965 print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][testnum], lengths[testnum]);
1967 count = run_benchmark(async_jobs, WHIRLPOOL_loop, loopargs);
1969 print_result(D_WHIRLPOOL, testnum, count, d);
1974 #ifndef OPENSSL_NO_RMD160
1975 if (doit[D_RMD160]) {
1976 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1977 print_message(names[D_RMD160], c[D_RMD160][testnum], lengths[testnum]);
1979 count = run_benchmark(async_jobs, EVP_Digest_RMD160_loop, loopargs);
1981 print_result(D_RMD160, testnum, count, d);
1985 #ifndef OPENSSL_NO_RC4
1987 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1988 print_message(names[D_RC4], c[D_RC4][testnum], lengths[testnum]);
1990 count = run_benchmark(async_jobs, RC4_loop, loopargs);
1992 print_result(D_RC4, testnum, count, d);
1996 #ifndef OPENSSL_NO_DES
1997 if (doit[D_CBC_DES]) {
1998 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1999 print_message(names[D_CBC_DES], c[D_CBC_DES][testnum], lengths[testnum]);
2001 count = run_benchmark(async_jobs, DES_ncbc_encrypt_loop, loopargs);
2003 print_result(D_CBC_DES, testnum, count, d);
2007 if (doit[D_EDE3_DES]) {
2008 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2009 print_message(names[D_EDE3_DES], c[D_EDE3_DES][testnum], lengths[testnum]);
2011 count = run_benchmark(async_jobs, DES_ede3_cbc_encrypt_loop, loopargs);
2013 print_result(D_EDE3_DES, testnum, count, d);
2018 if (doit[D_CBC_128_AES]) {
2019 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2020 print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][testnum],
2023 count = run_benchmark(async_jobs, AES_cbc_128_encrypt_loop, loopargs);
2025 print_result(D_CBC_128_AES, testnum, count, d);
2028 if (doit[D_CBC_192_AES]) {
2029 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2030 print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][testnum],
2033 count = run_benchmark(async_jobs, AES_cbc_192_encrypt_loop, loopargs);
2035 print_result(D_CBC_192_AES, testnum, count, d);
2038 if (doit[D_CBC_256_AES]) {
2039 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2040 print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][testnum],
2043 count = run_benchmark(async_jobs, AES_cbc_256_encrypt_loop, loopargs);
2045 print_result(D_CBC_256_AES, testnum, count, d);
2049 if (doit[D_IGE_128_AES]) {
2050 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2051 print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][testnum],
2054 count = run_benchmark(async_jobs, AES_ige_128_encrypt_loop, loopargs);
2056 print_result(D_IGE_128_AES, testnum, count, d);
2059 if (doit[D_IGE_192_AES]) {
2060 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2061 print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][testnum],
2064 count = run_benchmark(async_jobs, AES_ige_192_encrypt_loop, loopargs);
2066 print_result(D_IGE_192_AES, testnum, count, d);
2069 if (doit[D_IGE_256_AES]) {
2070 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2071 print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][testnum],
2074 count = run_benchmark(async_jobs, AES_ige_256_encrypt_loop, loopargs);
2076 print_result(D_IGE_256_AES, testnum, count, d);
2079 if (doit[D_GHASH]) {
2080 for (i = 0; i < loopargs_len; i++) {
2081 loopargs[i].gcm_ctx = CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
2082 CRYPTO_gcm128_setiv(loopargs[i].gcm_ctx, (unsigned char *)"0123456789ab", 12);
2085 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2086 print_message(names[D_GHASH], c[D_GHASH][testnum], lengths[testnum]);
2088 count = run_benchmark(async_jobs, CRYPTO_gcm128_aad_loop, loopargs);
2090 print_result(D_GHASH, testnum, count, d);
2092 for (i = 0; i < loopargs_len; i++)
2093 CRYPTO_gcm128_release(loopargs[i].gcm_ctx);
2096 #ifndef OPENSSL_NO_CAMELLIA
2097 if (doit[D_CBC_128_CML]) {
2098 if (async_jobs > 0) {
2099 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2100 names[D_CBC_128_CML]);
2101 doit[D_CBC_128_CML] = 0;
2103 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2104 print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][testnum],
2107 for (count = 0, run = 1; COND(c[D_CBC_128_CML][testnum]); count++)
2108 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2109 (size_t)lengths[testnum], &camellia_ks1,
2110 iv, CAMELLIA_ENCRYPT);
2112 print_result(D_CBC_128_CML, testnum, count, d);
2115 if (doit[D_CBC_192_CML]) {
2116 if (async_jobs > 0) {
2117 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2118 names[D_CBC_192_CML]);
2119 doit[D_CBC_192_CML] = 0;
2121 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2122 print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][testnum],
2124 if (async_jobs > 0) {
2125 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2129 for (count = 0, run = 1; COND(c[D_CBC_192_CML][testnum]); count++)
2130 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2131 (size_t)lengths[testnum], &camellia_ks2,
2132 iv, CAMELLIA_ENCRYPT);
2134 print_result(D_CBC_192_CML, testnum, count, d);
2137 if (doit[D_CBC_256_CML]) {
2138 if (async_jobs > 0) {
2139 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2140 names[D_CBC_256_CML]);
2141 doit[D_CBC_256_CML] = 0;
2143 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2144 print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][testnum],
2147 for (count = 0, run = 1; COND(c[D_CBC_256_CML][testnum]); count++)
2148 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2149 (size_t)lengths[testnum], &camellia_ks3,
2150 iv, CAMELLIA_ENCRYPT);
2152 print_result(D_CBC_256_CML, testnum, count, d);
2156 #ifndef OPENSSL_NO_IDEA
2157 if (doit[D_CBC_IDEA]) {
2158 if (async_jobs > 0) {
2159 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2161 doit[D_CBC_IDEA] = 0;
2163 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2164 print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][testnum], lengths[testnum]);
2166 for (count = 0, run = 1; COND(c[D_CBC_IDEA][testnum]); count++)
2167 IDEA_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2168 (size_t)lengths[testnum], &idea_ks,
2171 print_result(D_CBC_IDEA, testnum, count, d);
2175 #ifndef OPENSSL_NO_SEED
2176 if (doit[D_CBC_SEED]) {
2177 if (async_jobs > 0) {
2178 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2180 doit[D_CBC_SEED] = 0;
2182 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2183 print_message(names[D_CBC_SEED], c[D_CBC_SEED][testnum], lengths[testnum]);
2185 for (count = 0, run = 1; COND(c[D_CBC_SEED][testnum]); count++)
2186 SEED_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2187 (size_t)lengths[testnum], &seed_ks, iv, 1);
2189 print_result(D_CBC_SEED, testnum, count, d);
2193 #ifndef OPENSSL_NO_RC2
2194 if (doit[D_CBC_RC2]) {
2195 if (async_jobs > 0) {
2196 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2198 doit[D_CBC_RC2] = 0;
2200 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2201 print_message(names[D_CBC_RC2], c[D_CBC_RC2][testnum], lengths[testnum]);
2202 if (async_jobs > 0) {
2203 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2207 for (count = 0, run = 1; COND(c[D_CBC_RC2][testnum]); count++)
2208 RC2_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2209 (size_t)lengths[testnum], &rc2_ks,
2212 print_result(D_CBC_RC2, testnum, count, d);
2216 #ifndef OPENSSL_NO_RC5
2217 if (doit[D_CBC_RC5]) {
2218 if (async_jobs > 0) {
2219 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2221 doit[D_CBC_RC5] = 0;
2223 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2224 print_message(names[D_CBC_RC5], c[D_CBC_RC5][testnum], lengths[testnum]);
2225 if (async_jobs > 0) {
2226 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2230 for (count = 0, run = 1; COND(c[D_CBC_RC5][testnum]); count++)
2231 RC5_32_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2232 (size_t)lengths[testnum], &rc5_ks,
2235 print_result(D_CBC_RC5, testnum, count, d);
2239 #ifndef OPENSSL_NO_BF
2240 if (doit[D_CBC_BF]) {
2241 if (async_jobs > 0) {
2242 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2246 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2247 print_message(names[D_CBC_BF], c[D_CBC_BF][testnum], lengths[testnum]);
2249 for (count = 0, run = 1; COND(c[D_CBC_BF][testnum]); count++)
2250 BF_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2251 (size_t)lengths[testnum], &bf_ks,
2254 print_result(D_CBC_BF, testnum, count, d);
2258 #ifndef OPENSSL_NO_CAST
2259 if (doit[D_CBC_CAST]) {
2260 if (async_jobs > 0) {
2261 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2263 doit[D_CBC_CAST] = 0;
2265 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2266 print_message(names[D_CBC_CAST], c[D_CBC_CAST][testnum], lengths[testnum]);
2268 for (count = 0, run = 1; COND(c[D_CBC_CAST][testnum]); count++)
2269 CAST_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2270 (size_t)lengths[testnum], &cast_ks,
2273 print_result(D_CBC_CAST, testnum, count, d);
2279 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
2280 if (multiblock && evp_cipher) {
2282 (EVP_CIPHER_flags(evp_cipher) &
2283 EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
2284 BIO_printf(bio_err, "%s is not multi-block capable\n",
2285 OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
2288 if (async_jobs > 0) {
2289 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2292 multiblock_speed(evp_cipher);
2297 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2300 names[D_EVP] = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
2302 * -O3 -fschedule-insns messes up an optimization here!
2303 * names[D_EVP] somehow becomes NULL
2305 print_message(names[D_EVP], save_count, lengths[testnum]);
2307 for (k = 0; k < loopargs_len; k++) {
2308 loopargs[k].ctx = EVP_CIPHER_CTX_new();
2310 EVP_DecryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2312 EVP_EncryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2313 EVP_CIPHER_CTX_set_padding(loopargs[k].ctx, 0);
2317 count = run_benchmark(async_jobs, EVP_Update_loop, loopargs);
2319 for (k = 0; k < loopargs_len; k++) {
2320 EVP_CIPHER_CTX_free(loopargs[k].ctx);
2324 names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
2325 print_message(names[D_EVP], save_count, lengths[testnum]);
2327 count = run_benchmark(async_jobs, EVP_Digest_loop, loopargs);
2330 print_result(D_EVP, testnum, count, d);
2334 for (i = 0; i < loopargs_len; i++)
2335 RAND_bytes(loopargs[i].buf, 36);
2337 #ifndef OPENSSL_NO_RSA
2338 for (testnum = 0; testnum < RSA_NUM; testnum++) {
2340 if (!rsa_doit[testnum])
2342 for (i = 0; i < loopargs_len; i++) {
2343 st = RSA_sign(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2344 &loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2350 "RSA sign failure. No RSA sign will be done.\n");
2351 ERR_print_errors(bio_err);
2354 pkey_print_message("private", "rsa",
2355 rsa_c[testnum][0], rsa_bits[testnum], RSA_SECONDS);
2356 /* RSA_blinding_on(rsa_key[testnum],NULL); */
2358 count = run_benchmark(async_jobs, RSA_sign_loop, loopargs);
2361 mr ? "+R1:%ld:%d:%.2f\n"
2362 : "%ld %d bit private RSA's in %.2fs\n",
2363 count, rsa_bits[testnum], d);
2364 rsa_results[testnum][0] = d / (double)count;
2368 for (i = 0; i < loopargs_len; i++) {
2369 st = RSA_verify(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2370 loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2376 "RSA verify failure. No RSA verify will be done.\n");
2377 ERR_print_errors(bio_err);
2378 rsa_doit[testnum] = 0;
2380 pkey_print_message("public", "rsa",
2381 rsa_c[testnum][1], rsa_bits[testnum], RSA_SECONDS);
2383 count = run_benchmark(async_jobs, RSA_verify_loop, loopargs);
2386 mr ? "+R2:%ld:%d:%.2f\n"
2387 : "%ld %d bit public RSA's in %.2fs\n",
2388 count, rsa_bits[testnum], d);
2389 rsa_results[testnum][1] = d / (double)count;
2392 if (rsa_count <= 1) {
2393 /* if longer than 10s, don't do any more */
2394 for (testnum++; testnum < RSA_NUM; testnum++)
2395 rsa_doit[testnum] = 0;
2398 #endif /* OPENSSL_NO_RSA */
2400 for (i = 0; i < loopargs_len; i++)
2401 RAND_bytes(loopargs[i].buf, 36);
2403 #ifndef OPENSSL_NO_DSA
2404 if (RAND_status() != 1) {
2405 RAND_seed(rnd_seed, sizeof rnd_seed);
2407 for (testnum = 0; testnum < DSA_NUM; testnum++) {
2409 if (!dsa_doit[testnum])
2412 /* DSA_generate_key(dsa_key[testnum]); */
2413 /* DSA_sign_setup(dsa_key[testnum],NULL); */
2414 for (i = 0; i < loopargs_len; i++) {
2415 st = DSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2416 &loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2422 "DSA sign failure. No DSA sign will be done.\n");
2423 ERR_print_errors(bio_err);
2426 pkey_print_message("sign", "dsa",
2427 dsa_c[testnum][0], dsa_bits[testnum], DSA_SECONDS);
2429 count = run_benchmark(async_jobs, DSA_sign_loop, loopargs);
2432 mr ? "+R3:%ld:%d:%.2f\n"
2433 : "%ld %d bit DSA signs in %.2fs\n",
2434 count, dsa_bits[testnum], d);
2435 dsa_results[testnum][0] = d / (double)count;
2439 for (i = 0; i < loopargs_len; i++) {
2440 st = DSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2441 loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2447 "DSA verify failure. No DSA verify will be done.\n");
2448 ERR_print_errors(bio_err);
2449 dsa_doit[testnum] = 0;
2451 pkey_print_message("verify", "dsa",
2452 dsa_c[testnum][1], dsa_bits[testnum], DSA_SECONDS);
2454 count = run_benchmark(async_jobs, DSA_verify_loop, loopargs);
2457 mr ? "+R4:%ld:%d:%.2f\n"
2458 : "%ld %d bit DSA verify in %.2fs\n",
2459 count, dsa_bits[testnum], d);
2460 dsa_results[testnum][1] = d / (double)count;
2463 if (rsa_count <= 1) {
2464 /* if longer than 10s, don't do any more */
2465 for (testnum++; testnum < DSA_NUM; testnum++)
2466 dsa_doit[testnum] = 0;
2469 #endif /* OPENSSL_NO_DSA */
2471 #ifndef OPENSSL_NO_EC
2472 if (RAND_status() != 1) {
2473 RAND_seed(rnd_seed, sizeof rnd_seed);
2475 for (testnum = 0; testnum < EC_NUM; testnum++) {
2478 if (!ecdsa_doit[testnum])
2479 continue; /* Ignore Curve */
2480 for (i = 0; i < loopargs_len; i++) {
2481 loopargs[i].ecdsa[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2482 if (loopargs[i].ecdsa[testnum] == NULL) {
2488 BIO_printf(bio_err, "ECDSA failure.\n");
2489 ERR_print_errors(bio_err);
2492 for (i = 0; i < loopargs_len; i++) {
2493 EC_KEY_precompute_mult(loopargs[i].ecdsa[testnum], NULL);
2494 /* Perform ECDSA signature test */
2495 EC_KEY_generate_key(loopargs[i].ecdsa[testnum]);
2496 st = ECDSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2497 &loopargs[i].siglen, loopargs[i].ecdsa[testnum]);
2503 "ECDSA sign failure. No ECDSA sign will be done.\n");
2504 ERR_print_errors(bio_err);
2507 pkey_print_message("sign", "ecdsa",
2508 ecdsa_c[testnum][0],
2509 test_curves_bits[testnum], ECDSA_SECONDS);
2511 count = run_benchmark(async_jobs, ECDSA_sign_loop, loopargs);
2515 mr ? "+R5:%ld:%d:%.2f\n" :
2516 "%ld %d bit ECDSA signs in %.2fs \n",
2517 count, test_curves_bits[testnum], d);
2518 ecdsa_results[testnum][0] = d / (double)count;
2522 /* Perform ECDSA verification test */
2523 for (i = 0; i < loopargs_len; i++) {
2524 st = ECDSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2525 loopargs[i].siglen, loopargs[i].ecdsa[testnum]);
2531 "ECDSA verify failure. No ECDSA verify will be done.\n");
2532 ERR_print_errors(bio_err);
2533 ecdsa_doit[testnum] = 0;
2535 pkey_print_message("verify", "ecdsa",
2536 ecdsa_c[testnum][1],
2537 test_curves_bits[testnum], ECDSA_SECONDS);
2539 count = run_benchmark(async_jobs, ECDSA_verify_loop, loopargs);
2542 mr ? "+R6:%ld:%d:%.2f\n"
2543 : "%ld %d bit ECDSA verify in %.2fs\n",
2544 count, test_curves_bits[testnum], d);
2545 ecdsa_results[testnum][1] = d / (double)count;
2548 if (rsa_count <= 1) {
2549 /* if longer than 10s, don't do any more */
2550 for (testnum++; testnum < EC_NUM; testnum++)
2551 ecdsa_doit[testnum] = 0;
2556 if (RAND_status() != 1) {
2557 RAND_seed(rnd_seed, sizeof rnd_seed);
2559 for (testnum = 0; testnum < EC_NUM; testnum++) {
2560 int ecdh_checks = 1;
2562 if (!ecdh_doit[testnum])
2564 for (i = 0; i < loopargs_len; i++) {
2565 loopargs[i].ecdh_a[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2566 loopargs[i].ecdh_b[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2567 if (loopargs[i].ecdh_a[testnum] == NULL ||
2568 loopargs[i].ecdh_b[testnum] == NULL) {
2573 if (ecdh_checks == 0) {
2574 BIO_printf(bio_err, "ECDH failure.\n");
2575 ERR_print_errors(bio_err);
2578 for (i = 0; i < loopargs_len; i++) {
2579 /* generate two ECDH key pairs */
2580 if (!EC_KEY_generate_key(loopargs[i].ecdh_a[testnum]) ||
2581 !EC_KEY_generate_key(loopargs[i].ecdh_b[testnum])) {
2582 BIO_printf(bio_err, "ECDH key generation failure.\n");
2583 ERR_print_errors(bio_err);
2587 int secret_size_a, secret_size_b;
2589 * If field size is not more than 24 octets, then use SHA-1
2590 * hash of result; otherwise, use result (see section 4.8 of
2591 * draft-ietf-tls-ecc-03.txt).
2593 int field_size = EC_GROUP_get_degree(
2594 EC_KEY_get0_group(loopargs[i].ecdh_a[testnum]));
2596 if (field_size <= 24 * 8) { /* 192 bits */
2597 loopargs[i].outlen = KDF1_SHA1_len;
2598 loopargs[i].kdf = KDF1_SHA1;
2600 loopargs[i].outlen = (field_size + 7) / 8;
2601 loopargs[i].kdf = NULL;
2604 ECDH_compute_key(loopargs[i].secret_a, loopargs[i].outlen,
2605 EC_KEY_get0_public_key(loopargs[i].ecdh_b[testnum]),
2606 loopargs[i].ecdh_a[testnum], loopargs[i].kdf);
2608 ECDH_compute_key(loopargs[i].secret_b, loopargs[i].outlen,
2609 EC_KEY_get0_public_key(loopargs[i].ecdh_a[testnum]),
2610 loopargs[i].ecdh_b[testnum], loopargs[i].kdf);
2611 if (secret_size_a != secret_size_b)
2616 for (k = 0; k < secret_size_a && ecdh_checks == 1; k++) {
2617 if (loopargs[i].secret_a[k] != loopargs[i].secret_b[k])
2621 if (ecdh_checks == 0) {
2622 BIO_printf(bio_err, "ECDH computations don't match.\n");
2623 ERR_print_errors(bio_err);
2629 if (ecdh_checks != 0) {
2630 pkey_print_message("", "ecdh",
2632 test_curves_bits[testnum], ECDH_SECONDS);
2634 count = run_benchmark(async_jobs, ECDH_compute_key_loop, loopargs);
2637 mr ? "+R7:%ld:%d:%.2f\n" :
2638 "%ld %d-bit ECDH ops in %.2fs\n", count,
2639 test_curves_bits[testnum], d);
2640 ecdh_results[testnum][0] = d / (double)count;
2645 if (rsa_count <= 1) {
2646 /* if longer than 10s, don't do any more */
2647 for (testnum++; testnum < EC_NUM; testnum++)
2648 ecdh_doit[testnum] = 0;
2651 #endif /* OPENSSL_NO_EC */
2656 printf("%s\n", OpenSSL_version(OPENSSL_VERSION));
2657 printf("%s\n", OpenSSL_version(OPENSSL_BUILT_ON));
2659 printf("%s ", BN_options());
2660 #ifndef OPENSSL_NO_MD2
2661 printf("%s ", MD2_options());
2663 #ifndef OPENSSL_NO_RC4
2664 printf("%s ", RC4_options());
2666 #ifndef OPENSSL_NO_DES
2667 printf("%s ", DES_options());
2669 printf("%s ", AES_options());
2670 #ifndef OPENSSL_NO_IDEA
2671 printf("%s ", IDEA_options());
2673 #ifndef OPENSSL_NO_BF
2674 printf("%s ", BF_options());
2676 printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
2684 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2687 for (testnum = 0; testnum < SIZE_NUM; testnum++)
2688 printf(mr ? ":%d" : "%7d bytes", lengths[testnum]);
2692 for (k = 0; k < ALGOR_NUM; k++) {
2696 printf("+F:%d:%s", k, names[k]);
2698 printf("%-13s", names[k]);
2699 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2700 if (results[k][testnum] > 10000 && !mr)
2701 printf(" %11.2fk", results[k][testnum] / 1e3);
2703 printf(mr ? ":%.2f" : " %11.2f ", results[k][testnum]);
2707 #ifndef OPENSSL_NO_RSA
2709 for (k = 0; k < RSA_NUM; k++) {
2712 if (testnum && !mr) {
2713 printf("%18ssign verify sign/s verify/s\n", " ");
2717 printf("+F2:%u:%u:%f:%f\n",
2718 k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2720 printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2721 rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2722 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2725 #ifndef OPENSSL_NO_DSA
2727 for (k = 0; k < DSA_NUM; k++) {
2730 if (testnum && !mr) {
2731 printf("%18ssign verify sign/s verify/s\n", " ");
2735 printf("+F3:%u:%u:%f:%f\n",
2736 k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2738 printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2739 dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2740 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2743 #ifndef OPENSSL_NO_EC
2745 for (k = 0; k < EC_NUM; k++) {
2748 if (testnum && !mr) {
2749 printf("%30ssign verify sign/s verify/s\n", " ");
2754 printf("+F4:%u:%u:%f:%f\n",
2755 k, test_curves_bits[k],
2756 ecdsa_results[k][0], ecdsa_results[k][1]);
2758 printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2759 test_curves_bits[k],
2760 test_curves_names[k],
2761 ecdsa_results[k][0], ecdsa_results[k][1],
2762 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2766 for (k = 0; k < EC_NUM; k++) {
2769 if (testnum && !mr) {
2770 printf("%30sop op/s\n", " ");
2774 printf("+F5:%u:%u:%f:%f\n",
2775 k, test_curves_bits[k],
2776 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2779 printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2780 test_curves_bits[k],
2781 test_curves_names[k],
2782 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2789 ERR_print_errors(bio_err);
2790 for (i = 0; i < loopargs_len; i++) {
2791 OPENSSL_free(loopargs[i].buf_malloc);
2792 OPENSSL_free(loopargs[i].buf2_malloc);
2794 #ifndef OPENSSL_NO_RSA
2795 for (k = 0; k < RSA_NUM; k++)
2796 RSA_free(loopargs[i].rsa_key[k]);
2798 #ifndef OPENSSL_NO_DSA
2799 for (k = 0; k < DSA_NUM; k++)
2800 DSA_free(loopargs[i].dsa_key[k]);
2802 #ifndef OPENSSL_NO_EC
2803 for (k = 0; k < EC_NUM; k++) {
2804 EC_KEY_free(loopargs[i].ecdsa[k]);
2805 EC_KEY_free(loopargs[i].ecdh_a[k]);
2806 EC_KEY_free(loopargs[i].ecdh_b[k]);
2808 OPENSSL_free(loopargs[i].secret_a);
2809 OPENSSL_free(loopargs[i].secret_b);
2813 if (async_jobs > 0) {
2814 for (i = 0; i < loopargs_len; i++)
2815 ASYNC_WAIT_CTX_free(loopargs[i].wait_ctx);
2819 ASYNC_cleanup_thread();
2821 OPENSSL_free(loopargs);
2825 static void print_message(const char *s, long num, int length)
2829 mr ? "+DT:%s:%d:%d\n"
2830 : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2831 (void)BIO_flush(bio_err);
2835 mr ? "+DN:%s:%ld:%d\n"
2836 : "Doing %s %ld times on %d size blocks: ", s, num, length);
2837 (void)BIO_flush(bio_err);
2841 static void pkey_print_message(const char *str, const char *str2, long num,
2846 mr ? "+DTP:%d:%s:%s:%d\n"
2847 : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2848 (void)BIO_flush(bio_err);
2852 mr ? "+DNP:%ld:%d:%s:%s\n"
2853 : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2854 (void)BIO_flush(bio_err);
2858 static void print_result(int alg, int run_no, int count, double time_used)
2861 BIO_puts(bio_err, "EVP error!\n");
2865 mr ? "+R:%d:%s:%f\n"
2866 : "%d %s's in %.2fs\n", count, names[alg], time_used);
2867 results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2871 static char *sstrsep(char **string, const char *delim)
2874 char *token = *string;
2879 memset(isdelim, 0, sizeof isdelim);
2883 isdelim[(unsigned char)(*delim)] = 1;
2887 while (!isdelim[(unsigned char)(**string)]) {
2899 static int do_multi(int multi)
2904 static char sep[] = ":";
2906 fds = malloc(sizeof(*fds) * multi);
2907 for (n = 0; n < multi; ++n) {
2908 if (pipe(fd) == -1) {
2909 BIO_printf(bio_err, "pipe failure\n");
2913 (void)BIO_flush(bio_err);
2920 if (dup(fd[1]) == -1) {
2921 BIO_printf(bio_err, "dup failed\n");
2930 printf("Forked child %d\n", n);
2933 /* for now, assume the pipe is long enough to take all the output */
2934 for (n = 0; n < multi; ++n) {
2939 f = fdopen(fds[n], "r");
2940 while (fgets(buf, sizeof buf, f)) {
2941 p = strchr(buf, '\n');
2944 if (buf[0] != '+') {
2945 BIO_printf(bio_err, "Don't understand line '%s' from child %d\n",
2949 printf("Got: %s from %d\n", buf, n);
2950 if (strncmp(buf, "+F:", 3) == 0) {
2955 alg = atoi(sstrsep(&p, sep));
2957 for (j = 0; j < SIZE_NUM; ++j)
2958 results[alg][j] += atof(sstrsep(&p, sep));
2959 } else if (strncmp(buf, "+F2:", 4) == 0) {
2964 k = atoi(sstrsep(&p, sep));
2967 d = atof(sstrsep(&p, sep));
2969 rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
2971 rsa_results[k][0] = d;
2973 d = atof(sstrsep(&p, sep));
2975 rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
2977 rsa_results[k][1] = d;
2979 # ifndef OPENSSL_NO_DSA
2980 else if (strncmp(buf, "+F3:", 4) == 0) {
2985 k = atoi(sstrsep(&p, sep));
2988 d = atof(sstrsep(&p, sep));
2990 dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
2992 dsa_results[k][0] = d;
2994 d = atof(sstrsep(&p, sep));
2996 dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
2998 dsa_results[k][1] = d;
3001 # ifndef OPENSSL_NO_EC
3002 else if (strncmp(buf, "+F4:", 4) == 0) {
3007 k = atoi(sstrsep(&p, sep));
3010 d = atof(sstrsep(&p, sep));
3012 ecdsa_results[k][0] =
3013 1 / (1 / ecdsa_results[k][0] + 1 / d);
3015 ecdsa_results[k][0] = d;
3017 d = atof(sstrsep(&p, sep));
3019 ecdsa_results[k][1] =
3020 1 / (1 / ecdsa_results[k][1] + 1 / d);
3022 ecdsa_results[k][1] = d;
3023 } else if (strncmp(buf, "+F5:", 4) == 0) {
3028 k = atoi(sstrsep(&p, sep));
3031 d = atof(sstrsep(&p, sep));
3033 ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
3035 ecdh_results[k][0] = d;
3040 else if (strncmp(buf, "+H:", 3) == 0) {
3043 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf, n);
3053 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
3055 static int mblengths[] =
3056 { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
3057 int j, count, num = OSSL_NELEM(mblengths);
3058 const char *alg_name;
3059 unsigned char *inp, *out, no_key[32], no_iv[16];
3060 EVP_CIPHER_CTX *ctx;
3063 inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
3064 out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
3065 ctx = EVP_CIPHER_CTX_new();
3066 EVP_EncryptInit_ex(ctx, evp_cipher, NULL, no_key, no_iv);
3067 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key),
3069 alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
3071 for (j = 0; j < num; j++) {
3072 print_message(alg_name, 0, mblengths[j]);
3074 for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
3075 unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
3076 EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
3077 size_t len = mblengths[j];
3080 memset(aad, 0, 8); /* avoid uninitialized values */
3081 aad[8] = 23; /* SSL3_RT_APPLICATION_DATA */
3082 aad[9] = 3; /* version */
3084 aad[11] = 0; /* length */
3086 mb_param.out = NULL;
3089 mb_param.interleave = 8;
3091 packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
3092 sizeof(mb_param), &mb_param);
3098 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
3099 sizeof(mb_param), &mb_param);
3103 RAND_bytes(out, 16);
3107 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
3108 EVP_AEAD_TLS1_AAD_LEN, aad);
3109 EVP_Cipher(ctx, out, inp, len + pad);
3113 BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
3114 : "%d %s's in %.2fs\n", count, "evp", d);
3115 results[D_EVP][j] = ((double)count) / d * mblengths[j];
3119 fprintf(stdout, "+H");
3120 for (j = 0; j < num; j++)
3121 fprintf(stdout, ":%d", mblengths[j]);
3122 fprintf(stdout, "\n");
3123 fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
3124 for (j = 0; j < num; j++)
3125 fprintf(stdout, ":%.2f", results[D_EVP][j]);
3126 fprintf(stdout, "\n");
3129 "The 'numbers' are in 1000s of bytes per second processed.\n");
3130 fprintf(stdout, "type ");
3131 for (j = 0; j < num; j++)
3132 fprintf(stdout, "%7d bytes", mblengths[j]);
3133 fprintf(stdout, "\n");
3134 fprintf(stdout, "%-24s", alg_name);
3136 for (j = 0; j < num; j++) {
3137 if (results[D_EVP][j] > 10000)
3138 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
3140 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
3142 fprintf(stdout, "\n");
3147 EVP_CIPHER_CTX_free(ctx);