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;
157 unsigned int *siglen;
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 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 {"misalign", OPT_MISALIGN, 'n', "Amount to mis-align buffers"},
376 {"elapsed", OPT_ELAPSED, '-',
377 "Measure time in real time instead of CPU user time"},
379 {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"},
381 #ifndef OPENSSL_NO_ASYNC
382 {"async_jobs", OPT_ASYNCJOBS, 'p', "Enable async mode and start pnum jobs"},
384 #ifndef OPENSSL_NO_ENGINE
385 {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
400 #define D_CBC_IDEA 10
401 #define D_CBC_SEED 11
405 #define D_CBC_CAST 15
406 #define D_CBC_128_AES 16
407 #define D_CBC_192_AES 17
408 #define D_CBC_256_AES 18
409 #define D_CBC_128_CML 19
410 #define D_CBC_192_CML 20
411 #define D_CBC_256_CML 21
415 #define D_WHIRLPOOL 25
416 #define D_IGE_128_AES 26
417 #define D_IGE_192_AES 27
418 #define D_IGE_256_AES 28
420 static OPT_PAIR doit_choices[] = {
421 #ifndef OPENSSL_NO_MD2
424 #ifndef OPENSSL_NO_MDC2
427 #ifndef OPENSSL_NO_MD4
430 #ifndef OPENSSL_NO_MD5
433 #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},
557 static OPT_PAIR ecdh_choices[] = {
558 {"ecdhp160", R_EC_P160},
559 {"ecdhp192", R_EC_P192},
560 {"ecdhp224", R_EC_P224},
561 {"ecdhp256", R_EC_P256},
562 {"ecdhp384", R_EC_P384},
563 {"ecdhp521", R_EC_P521},
564 {"ecdhk163", R_EC_K163},
565 {"ecdhk233", R_EC_K233},
566 {"ecdhk283", R_EC_K283},
567 {"ecdhk409", R_EC_K409},
568 {"ecdhk571", R_EC_K571},
569 {"ecdhb163", R_EC_B163},
570 {"ecdhb233", R_EC_B233},
571 {"ecdhb283", R_EC_B283},
572 {"ecdhb409", R_EC_B409},
573 {"ecdhb571", R_EC_B571},
574 {"ecdhx25519", R_EC_X25519},
580 # define COND(d) (count < (d))
581 # define COUNT(d) (d)
583 # define COND(unused_cond) (run && count<0x7fffffff)
584 # define COUNT(d) (count)
589 /* Nb of iterations to do per algorithm and key-size */
590 static long c[ALGOR_NUM][SIZE_NUM];
592 #ifndef OPENSSL_NO_MD2
593 static int EVP_Digest_MD2_loop(void *args)
595 loopargs_t *tempargs = (loopargs_t *)args;
596 unsigned char *buf = tempargs->buf;
597 unsigned char md2[MD2_DIGEST_LENGTH];
600 for (count = 0; COND(c[D_MD2][testnum]); count++) {
601 if (!EVP_Digest(buf, (size_t)lengths[testnum], md2, NULL, EVP_md2(),
609 #ifndef OPENSSL_NO_MDC2
610 static int EVP_Digest_MDC2_loop(void *args)
612 loopargs_t *tempargs = (loopargs_t *)args;
613 unsigned char *buf = tempargs->buf;
614 unsigned char mdc2[MDC2_DIGEST_LENGTH];
617 for (count = 0; COND(c[D_MDC2][testnum]); count++) {
618 if (!EVP_Digest(buf, (size_t)lengths[testnum], mdc2, NULL, EVP_mdc2(),
626 #ifndef OPENSSL_NO_MD4
627 static int EVP_Digest_MD4_loop(void *args)
629 loopargs_t *tempargs = (loopargs_t *)args;
630 unsigned char *buf = tempargs->buf;
631 unsigned char md4[MD4_DIGEST_LENGTH];
634 for (count = 0; COND(c[D_MD4][testnum]); count++) {
635 if (!EVP_Digest(buf, (size_t)lengths[testnum], md4, NULL, EVP_md4(),
643 #ifndef OPENSSL_NO_MD5
644 static int MD5_loop(void *args)
646 loopargs_t *tempargs = (loopargs_t *)args;
647 unsigned char *buf = tempargs->buf;
648 unsigned char md5[MD5_DIGEST_LENGTH];
650 for (count = 0; COND(c[D_MD5][testnum]); count++)
651 MD5(buf, lengths[testnum], md5);
655 static int HMAC_loop(void *args)
657 loopargs_t *tempargs = (loopargs_t *)args;
658 unsigned char *buf = tempargs->buf;
659 HMAC_CTX *hctx = tempargs->hctx;
660 unsigned char hmac[MD5_DIGEST_LENGTH];
663 for (count = 0; COND(c[D_HMAC][testnum]); count++) {
664 HMAC_Init_ex(hctx, NULL, 0, NULL, NULL);
665 HMAC_Update(hctx, buf, lengths[testnum]);
666 HMAC_Final(hctx, hmac, NULL);
672 static int SHA1_loop(void *args)
674 loopargs_t *tempargs = (loopargs_t *)args;
675 unsigned char *buf = tempargs->buf;
676 unsigned char sha[SHA_DIGEST_LENGTH];
678 for (count = 0; COND(c[D_SHA1][testnum]); count++)
679 SHA1(buf, lengths[testnum], sha);
683 static int SHA256_loop(void *args)
685 loopargs_t *tempargs = (loopargs_t *)args;
686 unsigned char *buf = tempargs->buf;
687 unsigned char sha256[SHA256_DIGEST_LENGTH];
689 for (count = 0; COND(c[D_SHA256][testnum]); count++)
690 SHA256(buf, lengths[testnum], sha256);
694 static int SHA512_loop(void *args)
696 loopargs_t *tempargs = (loopargs_t *)args;
697 unsigned char *buf = tempargs->buf;
698 unsigned char sha512[SHA512_DIGEST_LENGTH];
700 for (count = 0; COND(c[D_SHA512][testnum]); count++)
701 SHA512(buf, lengths[testnum], sha512);
705 #ifndef OPENSSL_NO_WHIRLPOOL
706 static int WHIRLPOOL_loop(void *args)
708 loopargs_t *tempargs = (loopargs_t *)args;
709 unsigned char *buf = tempargs->buf;
710 unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];
712 for (count = 0; COND(c[D_WHIRLPOOL][testnum]); count++)
713 WHIRLPOOL(buf, lengths[testnum], whirlpool);
718 #ifndef OPENSSL_NO_RMD160
719 static int EVP_Digest_RMD160_loop(void *args)
721 loopargs_t *tempargs = (loopargs_t *)args;
722 unsigned char *buf = tempargs->buf;
723 unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
725 for (count = 0; COND(c[D_RMD160][testnum]); count++) {
726 if (!EVP_Digest(buf, (size_t)lengths[testnum], &(rmd160[0]),
727 NULL, EVP_ripemd160(), NULL))
734 #ifndef OPENSSL_NO_RC4
735 static RC4_KEY rc4_ks;
736 static int RC4_loop(void *args)
738 loopargs_t *tempargs = (loopargs_t *)args;
739 unsigned char *buf = tempargs->buf;
741 for (count = 0; COND(c[D_RC4][testnum]); count++)
742 RC4(&rc4_ks, (size_t)lengths[testnum], buf, buf);
747 #ifndef OPENSSL_NO_DES
748 static unsigned char DES_iv[8];
749 static DES_key_schedule sch;
750 static DES_key_schedule sch2;
751 static DES_key_schedule sch3;
752 static int DES_ncbc_encrypt_loop(void *args)
754 loopargs_t *tempargs = (loopargs_t *)args;
755 unsigned char *buf = tempargs->buf;
757 for (count = 0; COND(c[D_CBC_DES][testnum]); count++)
758 DES_ncbc_encrypt(buf, buf, lengths[testnum], &sch,
759 &DES_iv, DES_ENCRYPT);
763 static int DES_ede3_cbc_encrypt_loop(void *args)
765 loopargs_t *tempargs = (loopargs_t *)args;
766 unsigned char *buf = tempargs->buf;
768 for (count = 0; COND(c[D_EDE3_DES][testnum]); count++)
769 DES_ede3_cbc_encrypt(buf, buf, lengths[testnum],
771 &DES_iv, DES_ENCRYPT);
776 #define MAX_BLOCK_SIZE 128
778 static unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
779 static AES_KEY aes_ks1, aes_ks2, aes_ks3;
780 static int AES_cbc_128_encrypt_loop(void *args)
782 loopargs_t *tempargs = (loopargs_t *)args;
783 unsigned char *buf = tempargs->buf;
785 for (count = 0; COND(c[D_CBC_128_AES][testnum]); count++)
786 AES_cbc_encrypt(buf, buf,
787 (size_t)lengths[testnum], &aes_ks1,
792 static int AES_cbc_192_encrypt_loop(void *args)
794 loopargs_t *tempargs = (loopargs_t *)args;
795 unsigned char *buf = tempargs->buf;
797 for (count = 0; COND(c[D_CBC_192_AES][testnum]); count++)
798 AES_cbc_encrypt(buf, buf,
799 (size_t)lengths[testnum], &aes_ks2,
804 static int AES_cbc_256_encrypt_loop(void *args)
806 loopargs_t *tempargs = (loopargs_t *)args;
807 unsigned char *buf = tempargs->buf;
809 for (count = 0; COND(c[D_CBC_256_AES][testnum]); count++)
810 AES_cbc_encrypt(buf, buf,
811 (size_t)lengths[testnum], &aes_ks3,
816 static int AES_ige_128_encrypt_loop(void *args)
818 loopargs_t *tempargs = (loopargs_t *)args;
819 unsigned char *buf = tempargs->buf;
820 unsigned char *buf2 = tempargs->buf2;
822 for (count = 0; COND(c[D_IGE_128_AES][testnum]); count++)
823 AES_ige_encrypt(buf, buf2,
824 (size_t)lengths[testnum], &aes_ks1,
829 static int AES_ige_192_encrypt_loop(void *args)
831 loopargs_t *tempargs = (loopargs_t *)args;
832 unsigned char *buf = tempargs->buf;
833 unsigned char *buf2 = tempargs->buf2;
835 for (count = 0; COND(c[D_IGE_192_AES][testnum]); count++)
836 AES_ige_encrypt(buf, buf2,
837 (size_t)lengths[testnum], &aes_ks2,
842 static int AES_ige_256_encrypt_loop(void *args)
844 loopargs_t *tempargs = (loopargs_t *)args;
845 unsigned char *buf = tempargs->buf;
846 unsigned char *buf2 = tempargs->buf2;
848 for (count = 0; COND(c[D_IGE_256_AES][testnum]); count++)
849 AES_ige_encrypt(buf, buf2,
850 (size_t)lengths[testnum], &aes_ks3,
855 static int CRYPTO_gcm128_aad_loop(void *args)
857 loopargs_t *tempargs = (loopargs_t *)args;
858 unsigned char *buf = tempargs->buf;
859 GCM128_CONTEXT *gcm_ctx = tempargs->gcm_ctx;
861 for (count = 0; COND(c[D_GHASH][testnum]); count++)
862 CRYPTO_gcm128_aad(gcm_ctx, buf, lengths[testnum]);
866 static long save_count = 0;
867 static int decrypt = 0;
868 static int EVP_Update_loop(void *args)
870 loopargs_t *tempargs = (loopargs_t *)args;
871 unsigned char *buf = tempargs->buf;
872 EVP_CIPHER_CTX *ctx = tempargs->ctx;
875 int nb_iter = save_count * 4 * lengths[0] / lengths[testnum];
878 for (count = 0; COND(nb_iter); count++)
879 EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
881 for (count = 0; COND(nb_iter); count++)
882 EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
884 EVP_DecryptFinal_ex(ctx, buf, &outl);
886 EVP_EncryptFinal_ex(ctx, buf, &outl);
890 static const EVP_MD *evp_md = NULL;
891 static int EVP_Digest_loop(void *args)
893 loopargs_t *tempargs = (loopargs_t *)args;
894 unsigned char *buf = tempargs->buf;
895 unsigned char md[EVP_MAX_MD_SIZE];
898 int nb_iter = save_count * 4 * lengths[0] / lengths[testnum];
901 for (count = 0; COND(nb_iter); count++) {
902 if (!EVP_Digest(buf, lengths[testnum], md, NULL, evp_md, NULL))
908 #ifndef OPENSSL_NO_RSA
909 static long rsa_c[RSA_NUM][2]; /* # RSA iteration test */
911 static int RSA_sign_loop(void *args)
913 loopargs_t *tempargs = (loopargs_t *)args;
914 unsigned char *buf = tempargs->buf;
915 unsigned char *buf2 = tempargs->buf2;
916 unsigned int *rsa_num = tempargs->siglen;
917 RSA **rsa_key = tempargs->rsa_key;
919 for (count = 0; COND(rsa_c[testnum][0]); count++) {
920 ret = RSA_sign(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
922 BIO_printf(bio_err, "RSA sign failure\n");
923 ERR_print_errors(bio_err);
931 static int RSA_verify_loop(void *args)
933 loopargs_t *tempargs = (loopargs_t *)args;
934 unsigned char *buf = tempargs->buf;
935 unsigned char *buf2 = tempargs->buf2;
936 unsigned int rsa_num = *(tempargs->siglen);
937 RSA **rsa_key = tempargs->rsa_key;
939 for (count = 0; COND(rsa_c[testnum][1]); count++) {
940 ret = RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
942 BIO_printf(bio_err, "RSA verify failure\n");
943 ERR_print_errors(bio_err);
952 #ifndef OPENSSL_NO_DSA
953 static long dsa_c[DSA_NUM][2];
954 static int DSA_sign_loop(void *args)
956 loopargs_t *tempargs = (loopargs_t *)args;
957 unsigned char *buf = tempargs->buf;
958 unsigned char *buf2 = tempargs->buf2;
959 DSA **dsa_key = tempargs->dsa_key;
960 unsigned int *siglen = tempargs->siglen;
962 for (count = 0; COND(dsa_c[testnum][0]); count++) {
963 ret = DSA_sign(0, buf, 20, buf2, siglen, dsa_key[testnum]);
965 BIO_printf(bio_err, "DSA sign failure\n");
966 ERR_print_errors(bio_err);
974 static int DSA_verify_loop(void *args)
976 loopargs_t *tempargs = (loopargs_t *)args;
977 unsigned char *buf = tempargs->buf;
978 unsigned char *buf2 = tempargs->buf2;
979 DSA **dsa_key = tempargs->dsa_key;
980 unsigned int siglen = *(tempargs->siglen);
982 for (count = 0; COND(dsa_c[testnum][1]); count++) {
983 ret = DSA_verify(0, buf, 20, buf2, siglen, dsa_key[testnum]);
985 BIO_printf(bio_err, "DSA verify failure\n");
986 ERR_print_errors(bio_err);
995 #ifndef OPENSSL_NO_EC
996 static long ecdsa_c[EC_NUM][2];
997 static int ECDSA_sign_loop(void *args)
999 loopargs_t *tempargs = (loopargs_t *)args;
1000 unsigned char *buf = tempargs->buf;
1001 EC_KEY **ecdsa = tempargs->ecdsa;
1002 unsigned char *ecdsasig = tempargs->buf2;
1003 unsigned int *ecdsasiglen = tempargs->siglen;
1005 for (count = 0; COND(ecdsa_c[testnum][0]); count++) {
1006 ret = ECDSA_sign(0, buf, 20,
1007 ecdsasig, ecdsasiglen, ecdsa[testnum]);
1009 BIO_printf(bio_err, "ECDSA sign failure\n");
1010 ERR_print_errors(bio_err);
1018 static int ECDSA_verify_loop(void *args)
1020 loopargs_t *tempargs = (loopargs_t *)args;
1021 unsigned char *buf = tempargs->buf;
1022 EC_KEY **ecdsa = tempargs->ecdsa;
1023 unsigned char *ecdsasig = tempargs->buf2;
1024 unsigned int ecdsasiglen = *(tempargs->siglen);
1026 for (count = 0; COND(ecdsa_c[testnum][1]); count++) {
1027 ret = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen,
1030 BIO_printf(bio_err, "ECDSA verify failure\n");
1031 ERR_print_errors(bio_err);
1039 /* ******************************************************************** */
1040 static long ecdh_c[EC_NUM][1];
1042 static int ECDH_compute_key_loop(void *args)
1044 loopargs_t *tempargs = (loopargs_t *)args;
1045 EC_KEY **ecdh_a = tempargs->ecdh_a;
1046 EC_KEY **ecdh_b = tempargs->ecdh_b;
1047 unsigned char *secret_a = tempargs->secret_a;
1048 int count, outlen = tempargs->outlen;
1049 kdf_fn kdf = tempargs->kdf;
1051 for (count = 0; COND(ecdh_c[testnum][0]); count++) {
1052 ECDH_compute_key(secret_a, outlen,
1053 EC_KEY_get0_public_key(ecdh_b[testnum]),
1054 ecdh_a[testnum], kdf);
1059 static const int KDF1_SHA1_len = 20;
1060 static void *KDF1_SHA1(const void *in, size_t inlen, void *out,
1063 if (*outlen < SHA_DIGEST_LENGTH)
1065 *outlen = SHA_DIGEST_LENGTH;
1066 return SHA1(in, inlen, out);
1069 #endif /* ndef OPENSSL_NO_EC */
1072 static int run_benchmark(int async_jobs, int (*loop_function)(void *), loopargs_t *loopargs)
1074 int job_op_count = 0;
1075 int total_op_count = 0;
1076 int num_inprogress = 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);
1089 for (i = 0; i < async_jobs && !error; i++) {
1090 switch (ASYNC_start_job(&(loopargs[i].inprogress_job), loopargs[i].wait_ctx,
1091 &job_op_count, loop_function,
1092 (void *)(loopargs + i), sizeof(loopargs_t))) {
1097 if (job_op_count == -1) {
1100 total_op_count += job_op_count;
1105 BIO_printf(bio_err, "Failure in the job\n");
1106 ERR_print_errors(bio_err);
1112 while (num_inprogress > 0) {
1113 #if defined(OPENSSL_SYS_WINDOWS)
1115 #elif defined(OPENSSL_SYS_UNIX)
1116 int select_result = 0;
1117 OSSL_ASYNC_FD max_fd = 0;
1120 FD_ZERO(&waitfdset);
1122 for (i = 0; i < async_jobs && num_inprogress > 0; i++) {
1123 if (loopargs[i].inprogress_job == NULL)
1126 if (!ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, NULL, &num_job_fds)
1127 || num_job_fds > 1) {
1128 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1129 ERR_print_errors(bio_err);
1133 ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd, &num_job_fds);
1134 FD_SET(job_fd, &waitfdset);
1135 if (job_fd > max_fd)
1139 if (max_fd >= (OSSL_ASYNC_FD)FD_SETSIZE) {
1141 "Error: max_fd (%d) must be smaller than FD_SETSIZE (%d). "
1142 "Decrease the value of async_jobs\n",
1143 max_fd, FD_SETSIZE);
1144 ERR_print_errors(bio_err);
1149 select_result = select(max_fd + 1, &waitfdset, NULL, NULL, NULL);
1150 if (select_result == -1 && errno == EINTR)
1153 if (select_result == -1) {
1154 BIO_printf(bio_err, "Failure in the select\n");
1155 ERR_print_errors(bio_err);
1160 if (select_result == 0)
1164 for (i = 0; i < async_jobs; i++) {
1165 if (loopargs[i].inprogress_job == NULL)
1168 if (!ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, NULL, &num_job_fds)
1169 || num_job_fds > 1) {
1170 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1171 ERR_print_errors(bio_err);
1175 ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd, &num_job_fds);
1177 #if defined(OPENSSL_SYS_UNIX)
1178 if (num_job_fds == 1 && !FD_ISSET(job_fd, &waitfdset))
1180 #elif defined(OPENSSL_SYS_WINDOWS)
1181 if (num_job_fds == 1 &&
1182 !PeekNamedPipe(job_fd, NULL, 0, NULL, &avail, NULL) && avail > 0)
1186 switch (ASYNC_start_job(&(loopargs[i].inprogress_job), loopargs[i].wait_ctx,
1187 &job_op_count, loop_function, (void *)(loopargs + i),
1188 sizeof(loopargs_t))) {
1192 if (job_op_count == -1) {
1195 total_op_count += job_op_count;
1198 loopargs[i].inprogress_job = NULL;
1203 loopargs[i].inprogress_job = NULL;
1204 BIO_printf(bio_err, "Failure in the job\n");
1205 ERR_print_errors(bio_err);
1212 return error ? -1 : total_op_count;
1215 int speed_main(int argc, char **argv)
1217 loopargs_t *loopargs = NULL;
1219 int loopargs_len = 0;
1221 #ifndef OPENSSL_NO_ENGINE
1222 const char *engine_id = NULL;
1224 const EVP_CIPHER *evp_cipher = NULL;
1227 int multiblock = 0, pr_header = 0;
1228 int doit[ALGOR_NUM] = { 0 };
1229 int ret = 1, i, k, misalign = 0;
1235 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) \
1236 || !defined(OPENSSL_NO_EC)
1240 /* What follows are the buffers and key material. */
1241 #ifndef OPENSSL_NO_RC5
1244 #ifndef OPENSSL_NO_RC2
1247 #ifndef OPENSSL_NO_IDEA
1248 IDEA_KEY_SCHEDULE idea_ks;
1250 #ifndef OPENSSL_NO_SEED
1251 SEED_KEY_SCHEDULE seed_ks;
1253 #ifndef OPENSSL_NO_BF
1256 #ifndef OPENSSL_NO_CAST
1259 static const unsigned char key16[16] = {
1260 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1261 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1263 static const unsigned char key24[24] = {
1264 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1265 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1266 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1268 static const unsigned char key32[32] = {
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,
1272 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1274 #ifndef OPENSSL_NO_CAMELLIA
1275 static const unsigned char ckey24[24] = {
1276 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1277 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1278 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1280 static const unsigned char ckey32[32] = {
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,
1284 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1286 CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
1288 #ifndef OPENSSL_NO_DES
1289 static DES_cblock key = {
1290 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
1292 static DES_cblock key2 = {
1293 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1295 static DES_cblock key3 = {
1296 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1299 #ifndef OPENSSL_NO_RSA
1300 static const unsigned int rsa_bits[RSA_NUM] = {
1301 512, 1024, 2048, 3072, 4096, 7680, 15360
1303 static const unsigned char *rsa_data[RSA_NUM] = {
1304 test512, test1024, test2048, test3072, test4096, test7680, test15360
1306 static const int rsa_data_length[RSA_NUM] = {
1307 sizeof(test512), sizeof(test1024),
1308 sizeof(test2048), sizeof(test3072),
1309 sizeof(test4096), sizeof(test7680),
1312 int rsa_doit[RSA_NUM] = { 0 };
1314 #ifndef OPENSSL_NO_DSA
1315 static const unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
1316 int dsa_doit[DSA_NUM] = { 0 };
1318 #ifndef OPENSSL_NO_EC
1320 * We only test over the following curves as they are representative, To
1321 * add tests over more curves, simply add the curve NID and curve name to
1322 * the following arrays and increase the EC_NUM value accordingly.
1324 static const unsigned int test_curves[EC_NUM] = {
1326 NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
1327 NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
1329 NID_sect163k1, NID_sect233k1, NID_sect283k1,
1330 NID_sect409k1, NID_sect571k1, NID_sect163r2,
1331 NID_sect233r1, NID_sect283r1, NID_sect409r1,
1336 static const char *test_curves_names[EC_NUM] = {
1338 "secp160r1", "nistp192", "nistp224",
1339 "nistp256", "nistp384", "nistp521",
1341 "nistk163", "nistk233", "nistk283",
1342 "nistk409", "nistk571", "nistb163",
1343 "nistb233", "nistb283", "nistb409",
1348 static const int test_curves_bits[EC_NUM] = {
1354 571, 253 /* X25519 */
1357 int ecdsa_doit[EC_NUM] = { 0 };
1358 int ecdh_doit[EC_NUM] = { 0 };
1359 #endif /* ndef OPENSSL_NO_EC */
1361 prog = opt_init(argc, argv, speed_options);
1362 while ((o = opt_next()) != OPT_EOF) {
1367 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
1370 opt_help(speed_options);
1377 evp_cipher = EVP_get_cipherbyname(opt_arg());
1378 if (evp_cipher == NULL)
1379 evp_md = EVP_get_digestbyname(opt_arg());
1380 if (evp_cipher == NULL && evp_md == NULL) {
1382 "%s: %s an unknown cipher or digest\n",
1393 * In a forked execution, an engine might need to be
1394 * initialised by each child process, not by the parent.
1395 * So store the name here and run setup_engine() later on.
1397 #ifndef OPENSSL_NO_ENGINE
1398 engine_id = opt_arg();
1403 multi = atoi(opt_arg());
1407 #ifndef OPENSSL_NO_ASYNC
1408 async_jobs = atoi(opt_arg());
1409 if (!ASYNC_is_capable()) {
1411 "%s: async_jobs specified but async not supported\n",
1418 if (!opt_int(opt_arg(), &misalign))
1420 if (misalign > MISALIGN) {
1422 "%s: Maximum offset is %d\n", prog, MISALIGN);
1434 argc = opt_num_rest();
1437 /* Remaining arguments are algorithms. */
1438 for ( ; *argv; argv++) {
1439 if (found(*argv, doit_choices, &i)) {
1443 #ifndef OPENSSL_NO_DES
1444 if (strcmp(*argv, "des") == 0) {
1445 doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
1449 if (strcmp(*argv, "sha") == 0) {
1450 doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
1453 #ifndef OPENSSL_NO_RSA
1455 if (strcmp(*argv, "openssl") == 0) {
1456 RSA_set_default_method(RSA_PKCS1_OpenSSL());
1460 if (strcmp(*argv, "rsa") == 0) {
1461 rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
1462 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
1463 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
1464 rsa_doit[R_RSA_15360] = 1;
1467 if (found(*argv, rsa_choices, &i)) {
1472 #ifndef OPENSSL_NO_DSA
1473 if (strcmp(*argv, "dsa") == 0) {
1474 dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
1475 dsa_doit[R_DSA_2048] = 1;
1478 if (found(*argv, dsa_choices, &i)) {
1483 if (strcmp(*argv, "aes") == 0) {
1484 doit[D_CBC_128_AES] = doit[D_CBC_192_AES] =
1485 doit[D_CBC_256_AES] = 1;
1488 #ifndef OPENSSL_NO_CAMELLIA
1489 if (strcmp(*argv, "camellia") == 0) {
1490 doit[D_CBC_128_CML] = doit[D_CBC_192_CML] =
1491 doit[D_CBC_256_CML] = 1;
1495 #ifndef OPENSSL_NO_EC
1496 if (strcmp(*argv, "ecdsa") == 0) {
1497 for (i = 0; i < EC_NUM; i++)
1501 if (found(*argv, ecdsa_choices, &i)) {
1505 if (strcmp(*argv, "ecdh") == 0) {
1506 for (i = 0; i < EC_NUM; i++)
1510 if (found(*argv, ecdh_choices, &i)) {
1515 BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
1519 /* Initialize the job pool if async mode is enabled */
1520 if (async_jobs > 0) {
1521 async_init = ASYNC_init_thread(async_jobs, async_jobs);
1523 BIO_printf(bio_err, "Error creating the ASYNC job pool\n");
1528 loopargs_len = (async_jobs == 0 ? 1 : async_jobs);
1529 loopargs = app_malloc(loopargs_len * sizeof(loopargs_t), "array of loopargs");
1530 memset(loopargs, 0, loopargs_len * sizeof(loopargs_t));
1532 for (i = 0; i < loopargs_len; i++) {
1533 if (async_jobs > 0) {
1534 loopargs[i].wait_ctx = ASYNC_WAIT_CTX_new();
1535 if (loopargs[i].wait_ctx == NULL) {
1536 BIO_printf(bio_err, "Error creating the ASYNC_WAIT_CTX\n");
1541 loopargs[i].buf_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1542 loopargs[i].buf2_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1543 /* Align the start of buffers on a 64 byte boundary */
1544 loopargs[i].buf = loopargs[i].buf_malloc + misalign;
1545 loopargs[i].buf2 = loopargs[i].buf2_malloc + misalign;
1546 loopargs[i].siglen = app_malloc(sizeof(unsigned int), "signature length");
1547 #ifndef OPENSSL_NO_EC
1548 loopargs[i].secret_a = app_malloc(MAX_ECDH_SIZE, "ECDH secret a");
1549 loopargs[i].secret_b = app_malloc(MAX_ECDH_SIZE, "ECDH secret b");
1554 if (multi && do_multi(multi))
1558 /* Initialize the engine after the fork */
1559 (void)setup_engine(engine_id, 0);
1561 /* No parameters; turn on everything. */
1562 if ((argc == 0) && !doit[D_EVP]) {
1563 for (i = 0; i < ALGOR_NUM; i++)
1566 for (i = 0; i < RSA_NUM; i++)
1568 #ifndef OPENSSL_NO_DSA
1569 for (i = 0; i < DSA_NUM; i++)
1572 #ifndef OPENSSL_NO_EC
1573 for (i = 0; i < EC_NUM; i++)
1575 for (i = 0; i < EC_NUM; i++)
1579 for (i = 0; i < ALGOR_NUM; i++)
1583 if (usertime == 0 && !mr)
1585 "You have chosen to measure elapsed time "
1586 "instead of user CPU time.\n");
1588 #ifndef OPENSSL_NO_RSA
1589 for (i = 0; i < loopargs_len; i++) {
1590 for (k = 0; k < RSA_NUM; k++) {
1591 const unsigned char *p;
1594 loopargs[i].rsa_key[k] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[k]);
1595 if (loopargs[i].rsa_key[k] == NULL) {
1596 BIO_printf(bio_err, "internal error loading RSA key number %d\n",
1603 #ifndef OPENSSL_NO_DSA
1604 for (i = 0; i < loopargs_len; i++) {
1605 loopargs[i].dsa_key[0] = get_dsa512();
1606 loopargs[i].dsa_key[1] = get_dsa1024();
1607 loopargs[i].dsa_key[2] = get_dsa2048();
1610 #ifndef OPENSSL_NO_DES
1611 DES_set_key_unchecked(&key, &sch);
1612 DES_set_key_unchecked(&key2, &sch2);
1613 DES_set_key_unchecked(&key3, &sch3);
1615 AES_set_encrypt_key(key16, 128, &aes_ks1);
1616 AES_set_encrypt_key(key24, 192, &aes_ks2);
1617 AES_set_encrypt_key(key32, 256, &aes_ks3);
1618 #ifndef OPENSSL_NO_CAMELLIA
1619 Camellia_set_key(key16, 128, &camellia_ks1);
1620 Camellia_set_key(ckey24, 192, &camellia_ks2);
1621 Camellia_set_key(ckey32, 256, &camellia_ks3);
1623 #ifndef OPENSSL_NO_IDEA
1624 IDEA_set_encrypt_key(key16, &idea_ks);
1626 #ifndef OPENSSL_NO_SEED
1627 SEED_set_key(key16, &seed_ks);
1629 #ifndef OPENSSL_NO_RC4
1630 RC4_set_key(&rc4_ks, 16, key16);
1632 #ifndef OPENSSL_NO_RC2
1633 RC2_set_key(&rc2_ks, 16, key16, 128);
1635 #ifndef OPENSSL_NO_RC5
1636 RC5_32_set_key(&rc5_ks, 16, key16, 12);
1638 #ifndef OPENSSL_NO_BF
1639 BF_set_key(&bf_ks, 16, key16);
1641 #ifndef OPENSSL_NO_CAST
1642 CAST_set_key(&cast_ks, 16, key16);
1645 # ifndef OPENSSL_NO_DES
1646 BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1652 for (it = count; it; it--)
1653 DES_ecb_encrypt((DES_cblock *)loopargs[0].buf,
1654 (DES_cblock *)loopargs[0].buf, &sch, DES_ENCRYPT);
1658 c[D_MD2][0] = count / 10;
1659 c[D_MDC2][0] = count / 10;
1660 c[D_MD4][0] = count;
1661 c[D_MD5][0] = count;
1662 c[D_HMAC][0] = count;
1663 c[D_SHA1][0] = count;
1664 c[D_RMD160][0] = count;
1665 c[D_RC4][0] = count * 5;
1666 c[D_CBC_DES][0] = count;
1667 c[D_EDE3_DES][0] = count / 3;
1668 c[D_CBC_IDEA][0] = count;
1669 c[D_CBC_SEED][0] = count;
1670 c[D_CBC_RC2][0] = count;
1671 c[D_CBC_RC5][0] = count;
1672 c[D_CBC_BF][0] = count;
1673 c[D_CBC_CAST][0] = count;
1674 c[D_CBC_128_AES][0] = count;
1675 c[D_CBC_192_AES][0] = count;
1676 c[D_CBC_256_AES][0] = count;
1677 c[D_CBC_128_CML][0] = count;
1678 c[D_CBC_192_CML][0] = count;
1679 c[D_CBC_256_CML][0] = count;
1680 c[D_SHA256][0] = count;
1681 c[D_SHA512][0] = count;
1682 c[D_WHIRLPOOL][0] = count;
1683 c[D_IGE_128_AES][0] = count;
1684 c[D_IGE_192_AES][0] = count;
1685 c[D_IGE_256_AES][0] = count;
1686 c[D_GHASH][0] = count;
1688 for (i = 1; i < SIZE_NUM; i++) {
1691 l0 = (long)lengths[0];
1692 l1 = (long)lengths[i];
1694 c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1695 c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1696 c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1697 c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1698 c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1699 c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1700 c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1701 c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1702 c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1703 c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1704 c[D_GHASH][i] = c[D_GHASH][0] * 4 * l0 / l1;
1706 l0 = (long)lengths[i - 1];
1708 c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1709 c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1710 c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1711 c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1712 c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1713 c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1714 c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1715 c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1716 c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1717 c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1718 c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1719 c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1720 c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1721 c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1722 c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1723 c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1724 c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1725 c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1728 # ifndef OPENSSL_NO_RSA
1729 rsa_c[R_RSA_512][0] = count / 2000;
1730 rsa_c[R_RSA_512][1] = count / 400;
1731 for (i = 1; i < RSA_NUM; i++) {
1732 rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1733 rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1734 if (rsa_doit[i] <= 1 && rsa_c[i][0] == 0)
1737 if (rsa_c[i][0] == 0) {
1738 rsa_c[i][0] = 1; /* Set minimum iteration Nb to 1. */
1745 # ifndef OPENSSL_NO_DSA
1746 dsa_c[R_DSA_512][0] = count / 1000;
1747 dsa_c[R_DSA_512][1] = count / 1000 / 2;
1748 for (i = 1; i < DSA_NUM; i++) {
1749 dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1750 dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1751 if (dsa_doit[i] <= 1 && dsa_c[i][0] == 0)
1754 if (dsa_c[i][0] == 0) {
1755 dsa_c[i][0] = 1; /* Set minimum iteration Nb to 1. */
1762 # ifndef OPENSSL_NO_EC
1763 ecdsa_c[R_EC_P160][0] = count / 1000;
1764 ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1765 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1766 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1767 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1768 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1771 if (ecdsa_c[i][0] == 0) {
1777 ecdsa_c[R_EC_K163][0] = count / 1000;
1778 ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1779 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1780 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1781 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1782 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1785 if (ecdsa_c[i][0] == 0) {
1791 ecdsa_c[R_EC_B163][0] = count / 1000;
1792 ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1793 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1794 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1795 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1796 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1799 if (ecdsa_c[i][0] == 0) {
1806 ecdh_c[R_EC_P160][0] = count / 1000;
1807 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1808 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1809 if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1812 if (ecdh_c[i][0] == 0) {
1817 ecdh_c[R_EC_K163][0] = count / 1000;
1818 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1819 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1820 if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1823 if (ecdh_c[i][0] == 0) {
1828 ecdh_c[R_EC_B163][0] = count / 1000;
1829 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1830 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1831 if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1834 if (ecdh_c[i][0] == 0) {
1842 /* not worth fixing */
1843 # error "You cannot disable DES on systems without SIGALRM."
1844 # endif /* OPENSSL_NO_DES */
1847 signal(SIGALRM, sig_done);
1849 #endif /* SIGALRM */
1851 #ifndef OPENSSL_NO_MD2
1853 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1854 print_message(names[D_MD2], c[D_MD2][testnum], lengths[testnum]);
1856 count = run_benchmark(async_jobs, EVP_Digest_MD2_loop, loopargs);
1858 print_result(D_MD2, testnum, count, d);
1862 #ifndef OPENSSL_NO_MDC2
1864 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1865 print_message(names[D_MDC2], c[D_MDC2][testnum], lengths[testnum]);
1867 count = run_benchmark(async_jobs, EVP_Digest_MDC2_loop, loopargs);
1869 print_result(D_MDC2, testnum, count, d);
1874 #ifndef OPENSSL_NO_MD4
1876 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1877 print_message(names[D_MD4], c[D_MD4][testnum], lengths[testnum]);
1879 count = run_benchmark(async_jobs, EVP_Digest_MD4_loop, loopargs);
1881 print_result(D_MD4, testnum, count, d);
1886 #ifndef OPENSSL_NO_MD5
1888 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1889 print_message(names[D_MD5], c[D_MD5][testnum], lengths[testnum]);
1891 count = run_benchmark(async_jobs, MD5_loop, loopargs);
1893 print_result(D_MD5, testnum, count, d);
1898 #ifndef OPENSSL_NO_MD5
1900 char hmac_key[] = "This is a key...";
1901 int len = strlen(hmac_key);
1903 for (i = 0; i < loopargs_len; i++) {
1904 loopargs[i].hctx = HMAC_CTX_new();
1905 if (loopargs[i].hctx == NULL) {
1906 BIO_printf(bio_err, "HMAC malloc failure, exiting...");
1910 HMAC_Init_ex(loopargs[i].hctx, hmac_key, len, EVP_md5(), NULL);
1912 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1913 print_message(names[D_HMAC], c[D_HMAC][testnum], lengths[testnum]);
1915 count = run_benchmark(async_jobs, HMAC_loop, loopargs);
1917 print_result(D_HMAC, testnum, count, d);
1919 for (i = 0; i < loopargs_len; i++) {
1920 HMAC_CTX_free(loopargs[i].hctx);
1925 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1926 print_message(names[D_SHA1], c[D_SHA1][testnum], lengths[testnum]);
1928 count = run_benchmark(async_jobs, SHA1_loop, loopargs);
1930 print_result(D_SHA1, testnum, count, d);
1933 if (doit[D_SHA256]) {
1934 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1935 print_message(names[D_SHA256], c[D_SHA256][testnum], lengths[testnum]);
1937 count = run_benchmark(async_jobs, SHA256_loop, loopargs);
1939 print_result(D_SHA256, testnum, count, d);
1942 if (doit[D_SHA512]) {
1943 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1944 print_message(names[D_SHA512], c[D_SHA512][testnum], lengths[testnum]);
1946 count = run_benchmark(async_jobs, SHA512_loop, loopargs);
1948 print_result(D_SHA512, testnum, count, d);
1952 #ifndef OPENSSL_NO_WHIRLPOOL
1953 if (doit[D_WHIRLPOOL]) {
1954 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1955 print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][testnum], lengths[testnum]);
1957 count = run_benchmark(async_jobs, WHIRLPOOL_loop, loopargs);
1959 print_result(D_WHIRLPOOL, testnum, count, d);
1964 #ifndef OPENSSL_NO_RMD160
1965 if (doit[D_RMD160]) {
1966 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1967 print_message(names[D_RMD160], c[D_RMD160][testnum], lengths[testnum]);
1969 count = run_benchmark(async_jobs, EVP_Digest_RMD160_loop, loopargs);
1971 print_result(D_RMD160, testnum, count, d);
1975 #ifndef OPENSSL_NO_RC4
1977 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1978 print_message(names[D_RC4], c[D_RC4][testnum], lengths[testnum]);
1980 count = run_benchmark(async_jobs, RC4_loop, loopargs);
1982 print_result(D_RC4, testnum, count, d);
1986 #ifndef OPENSSL_NO_DES
1987 if (doit[D_CBC_DES]) {
1988 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1989 print_message(names[D_CBC_DES], c[D_CBC_DES][testnum], lengths[testnum]);
1991 count = run_benchmark(async_jobs, DES_ncbc_encrypt_loop, loopargs);
1993 print_result(D_CBC_DES, testnum, count, d);
1997 if (doit[D_EDE3_DES]) {
1998 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1999 print_message(names[D_EDE3_DES], c[D_EDE3_DES][testnum], lengths[testnum]);
2001 count = run_benchmark(async_jobs, DES_ede3_cbc_encrypt_loop, loopargs);
2003 print_result(D_EDE3_DES, testnum, count, d);
2008 if (doit[D_CBC_128_AES]) {
2009 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2010 print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][testnum],
2013 count = run_benchmark(async_jobs, AES_cbc_128_encrypt_loop, loopargs);
2015 print_result(D_CBC_128_AES, testnum, count, d);
2018 if (doit[D_CBC_192_AES]) {
2019 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2020 print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][testnum],
2023 count = run_benchmark(async_jobs, AES_cbc_192_encrypt_loop, loopargs);
2025 print_result(D_CBC_192_AES, testnum, count, d);
2028 if (doit[D_CBC_256_AES]) {
2029 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2030 print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][testnum],
2033 count = run_benchmark(async_jobs, AES_cbc_256_encrypt_loop, loopargs);
2035 print_result(D_CBC_256_AES, testnum, count, d);
2039 if (doit[D_IGE_128_AES]) {
2040 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2041 print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][testnum],
2044 count = run_benchmark(async_jobs, AES_ige_128_encrypt_loop, loopargs);
2046 print_result(D_IGE_128_AES, testnum, count, d);
2049 if (doit[D_IGE_192_AES]) {
2050 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2051 print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][testnum],
2054 count = run_benchmark(async_jobs, AES_ige_192_encrypt_loop, loopargs);
2056 print_result(D_IGE_192_AES, testnum, count, d);
2059 if (doit[D_IGE_256_AES]) {
2060 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2061 print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][testnum],
2064 count = run_benchmark(async_jobs, AES_ige_256_encrypt_loop, loopargs);
2066 print_result(D_IGE_256_AES, testnum, count, d);
2069 if (doit[D_GHASH]) {
2070 for (i = 0; i < loopargs_len; i++) {
2071 loopargs[i].gcm_ctx = CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
2072 CRYPTO_gcm128_setiv(loopargs[i].gcm_ctx, (unsigned char *)"0123456789ab", 12);
2075 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2076 print_message(names[D_GHASH], c[D_GHASH][testnum], lengths[testnum]);
2078 count = run_benchmark(async_jobs, CRYPTO_gcm128_aad_loop, loopargs);
2080 print_result(D_GHASH, testnum, count, d);
2082 for (i = 0; i < loopargs_len; i++)
2083 CRYPTO_gcm128_release(loopargs[i].gcm_ctx);
2086 #ifndef OPENSSL_NO_CAMELLIA
2087 if (doit[D_CBC_128_CML]) {
2088 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2089 print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][testnum],
2091 if (async_jobs > 0) {
2092 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2096 for (count = 0, run = 1; COND(c[D_CBC_128_CML][testnum]); count++)
2097 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2098 (size_t)lengths[testnum], &camellia_ks1,
2099 iv, CAMELLIA_ENCRYPT);
2101 print_result(D_CBC_128_CML, testnum, count, d);
2104 if (doit[D_CBC_192_CML]) {
2105 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2106 print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][testnum],
2108 if (async_jobs > 0) {
2109 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2113 for (count = 0, run = 1; COND(c[D_CBC_192_CML][testnum]); count++)
2114 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2115 (size_t)lengths[testnum], &camellia_ks2,
2116 iv, CAMELLIA_ENCRYPT);
2118 print_result(D_CBC_192_CML, testnum, count, d);
2121 if (doit[D_CBC_256_CML]) {
2122 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2123 print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][testnum],
2125 if (async_jobs > 0) {
2126 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2130 for (count = 0, run = 1; COND(c[D_CBC_256_CML][testnum]); count++)
2131 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2132 (size_t)lengths[testnum], &camellia_ks3,
2133 iv, CAMELLIA_ENCRYPT);
2135 print_result(D_CBC_256_CML, testnum, count, d);
2139 #ifndef OPENSSL_NO_IDEA
2140 if (doit[D_CBC_IDEA]) {
2141 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2142 print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][testnum], lengths[testnum]);
2143 if (async_jobs > 0) {
2144 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2148 for (count = 0, run = 1; COND(c[D_CBC_IDEA][testnum]); count++)
2149 IDEA_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2150 (size_t)lengths[testnum], &idea_ks,
2153 print_result(D_CBC_IDEA, testnum, count, d);
2157 #ifndef OPENSSL_NO_SEED
2158 if (doit[D_CBC_SEED]) {
2159 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2160 print_message(names[D_CBC_SEED], c[D_CBC_SEED][testnum], lengths[testnum]);
2161 if (async_jobs > 0) {
2162 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2166 for (count = 0, run = 1; COND(c[D_CBC_SEED][testnum]); count++)
2167 SEED_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2168 (size_t)lengths[testnum], &seed_ks, iv, 1);
2170 print_result(D_CBC_SEED, testnum, count, d);
2174 #ifndef OPENSSL_NO_RC2
2175 if (doit[D_CBC_RC2]) {
2176 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2177 print_message(names[D_CBC_RC2], c[D_CBC_RC2][testnum], lengths[testnum]);
2178 if (async_jobs > 0) {
2179 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2183 for (count = 0, run = 1; COND(c[D_CBC_RC2][testnum]); count++)
2184 RC2_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2185 (size_t)lengths[testnum], &rc2_ks,
2188 print_result(D_CBC_RC2, testnum, count, d);
2192 #ifndef OPENSSL_NO_RC5
2193 if (doit[D_CBC_RC5]) {
2194 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2195 print_message(names[D_CBC_RC5], c[D_CBC_RC5][testnum], lengths[testnum]);
2196 if (async_jobs > 0) {
2197 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2201 for (count = 0, run = 1; COND(c[D_CBC_RC5][testnum]); count++)
2202 RC5_32_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2203 (size_t)lengths[testnum], &rc5_ks,
2206 print_result(D_CBC_RC5, testnum, count, d);
2210 #ifndef OPENSSL_NO_BF
2211 if (doit[D_CBC_BF]) {
2212 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2213 print_message(names[D_CBC_BF], c[D_CBC_BF][testnum], lengths[testnum]);
2214 if (async_jobs > 0) {
2215 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2219 for (count = 0, run = 1; COND(c[D_CBC_BF][testnum]); count++)
2220 BF_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2221 (size_t)lengths[testnum], &bf_ks,
2224 print_result(D_CBC_BF, testnum, count, d);
2228 #ifndef OPENSSL_NO_CAST
2229 if (doit[D_CBC_CAST]) {
2230 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2231 print_message(names[D_CBC_CAST], c[D_CBC_CAST][testnum], lengths[testnum]);
2232 if (async_jobs > 0) {
2233 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2237 for (count = 0, run = 1; COND(c[D_CBC_CAST][testnum]); count++)
2238 CAST_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2239 (size_t)lengths[testnum], &cast_ks,
2242 print_result(D_CBC_CAST, testnum, count, d);
2248 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
2249 if (multiblock && evp_cipher) {
2251 (EVP_CIPHER_flags(evp_cipher) &
2252 EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
2253 BIO_printf(bio_err, "%s is not multi-block capable\n",
2254 OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
2257 if (async_jobs > 0) {
2258 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2261 multiblock_speed(evp_cipher);
2266 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2269 names[D_EVP] = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
2271 * -O3 -fschedule-insns messes up an optimization here!
2272 * names[D_EVP] somehow becomes NULL
2274 print_message(names[D_EVP], save_count, lengths[testnum]);
2276 for (k = 0; k < loopargs_len; k++) {
2277 loopargs[k].ctx = EVP_CIPHER_CTX_new();
2279 EVP_DecryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2281 EVP_EncryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2282 EVP_CIPHER_CTX_set_padding(loopargs[k].ctx, 0);
2286 count = run_benchmark(async_jobs, EVP_Update_loop, loopargs);
2288 for (k = 0; k < loopargs_len; k++) {
2289 EVP_CIPHER_CTX_free(loopargs[k].ctx);
2293 names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
2294 print_message(names[D_EVP], save_count, lengths[testnum]);
2296 count = run_benchmark(async_jobs, EVP_Digest_loop, loopargs);
2299 print_result(D_EVP, testnum, count, d);
2303 for (i = 0; i < loopargs_len; i++)
2304 RAND_bytes(loopargs[i].buf, 36);
2306 #ifndef OPENSSL_NO_RSA
2307 for (testnum = 0; testnum < RSA_NUM; testnum++) {
2309 if (!rsa_doit[testnum])
2311 for (i = 0; i < loopargs_len; i++) {
2312 st = RSA_sign(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2313 loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2319 "RSA sign failure. No RSA sign will be done.\n");
2320 ERR_print_errors(bio_err);
2323 pkey_print_message("private", "rsa",
2324 rsa_c[testnum][0], rsa_bits[testnum], RSA_SECONDS);
2325 /* RSA_blinding_on(rsa_key[testnum],NULL); */
2327 count = run_benchmark(async_jobs, RSA_sign_loop, loopargs);
2330 mr ? "+R1:%ld:%d:%.2f\n"
2331 : "%ld %d bit private RSA's in %.2fs\n",
2332 count, rsa_bits[testnum], d);
2333 rsa_results[testnum][0] = d / (double)count;
2337 for (i = 0; i < loopargs_len; i++) {
2338 st = RSA_verify(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2339 *(loopargs[i].siglen), loopargs[i].rsa_key[testnum]);
2345 "RSA verify failure. No RSA verify will be done.\n");
2346 ERR_print_errors(bio_err);
2347 rsa_doit[testnum] = 0;
2349 pkey_print_message("public", "rsa",
2350 rsa_c[testnum][1], rsa_bits[testnum], RSA_SECONDS);
2352 count = run_benchmark(async_jobs, RSA_verify_loop, loopargs);
2355 mr ? "+R2:%ld:%d:%.2f\n"
2356 : "%ld %d bit public RSA's in %.2fs\n",
2357 count, rsa_bits[testnum], d);
2358 rsa_results[testnum][1] = d / (double)count;
2361 if (rsa_count <= 1) {
2362 /* if longer than 10s, don't do any more */
2363 for (testnum++; testnum < RSA_NUM; testnum++)
2364 rsa_doit[testnum] = 0;
2369 for (i = 0; i < loopargs_len; i++)
2370 RAND_bytes(loopargs[i].buf, 36);
2372 #ifndef OPENSSL_NO_DSA
2373 if (RAND_status() != 1) {
2374 RAND_seed(rnd_seed, sizeof rnd_seed);
2376 for (testnum = 0; testnum < DSA_NUM; testnum++) {
2378 if (!dsa_doit[testnum])
2381 /* DSA_generate_key(dsa_key[testnum]); */
2382 /* DSA_sign_setup(dsa_key[testnum],NULL); */
2383 for (i = 0; i < loopargs_len; i++) {
2384 st = DSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2385 loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2391 "DSA sign failure. No DSA sign will be done.\n");
2392 ERR_print_errors(bio_err);
2395 pkey_print_message("sign", "dsa",
2396 dsa_c[testnum][0], dsa_bits[testnum], DSA_SECONDS);
2398 count = run_benchmark(async_jobs, DSA_sign_loop, loopargs);
2401 mr ? "+R3:%ld:%d:%.2f\n"
2402 : "%ld %d bit DSA signs in %.2fs\n",
2403 count, dsa_bits[testnum], d);
2404 dsa_results[testnum][0] = d / (double)count;
2408 for (i = 0; i < loopargs_len; i++) {
2409 st = DSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2410 *(loopargs[i].siglen), loopargs[i].dsa_key[testnum]);
2416 "DSA verify failure. No DSA verify will be done.\n");
2417 ERR_print_errors(bio_err);
2418 dsa_doit[testnum] = 0;
2420 pkey_print_message("verify", "dsa",
2421 dsa_c[testnum][1], dsa_bits[testnum], DSA_SECONDS);
2423 count = run_benchmark(async_jobs, DSA_verify_loop, loopargs);
2426 mr ? "+R4:%ld:%d:%.2f\n"
2427 : "%ld %d bit DSA verify in %.2fs\n",
2428 count, dsa_bits[testnum], d);
2429 dsa_results[testnum][1] = d / (double)count;
2432 if (rsa_count <= 1) {
2433 /* if longer than 10s, don't do any more */
2434 for (testnum++; testnum < DSA_NUM; testnum++)
2435 dsa_doit[testnum] = 0;
2440 #ifndef OPENSSL_NO_EC
2441 if (RAND_status() != 1) {
2442 RAND_seed(rnd_seed, sizeof rnd_seed);
2444 for (testnum = 0; testnum < EC_NUM; testnum++) {
2447 if (!ecdsa_doit[testnum])
2448 continue; /* Ignore Curve */
2449 for (i = 0; i < loopargs_len; i++) {
2450 loopargs[i].ecdsa[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2451 if (loopargs[i].ecdsa[testnum] == NULL) {
2457 BIO_printf(bio_err, "ECDSA failure.\n");
2458 ERR_print_errors(bio_err);
2461 for (i = 0; i < loopargs_len; i++) {
2462 EC_KEY_precompute_mult(loopargs[i].ecdsa[testnum], NULL);
2463 /* Perform ECDSA signature test */
2464 EC_KEY_generate_key(loopargs[i].ecdsa[testnum]);
2465 st = ECDSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2466 loopargs[i].siglen, loopargs[i].ecdsa[testnum]);
2472 "ECDSA sign failure. No ECDSA sign will be done.\n");
2473 ERR_print_errors(bio_err);
2476 pkey_print_message("sign", "ecdsa",
2477 ecdsa_c[testnum][0],
2478 test_curves_bits[testnum], ECDSA_SECONDS);
2480 count = run_benchmark(async_jobs, ECDSA_sign_loop, loopargs);
2484 mr ? "+R5:%ld:%d:%.2f\n" :
2485 "%ld %d bit ECDSA signs in %.2fs \n",
2486 count, test_curves_bits[testnum], d);
2487 ecdsa_results[testnum][0] = d / (double)count;
2491 /* Perform ECDSA verification test */
2492 for (i = 0; i < loopargs_len; i++) {
2493 st = ECDSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2494 *(loopargs[i].siglen), loopargs[i].ecdsa[testnum]);
2500 "ECDSA verify failure. No ECDSA verify will be done.\n");
2501 ERR_print_errors(bio_err);
2502 ecdsa_doit[testnum] = 0;
2504 pkey_print_message("verify", "ecdsa",
2505 ecdsa_c[testnum][1],
2506 test_curves_bits[testnum], ECDSA_SECONDS);
2508 count = run_benchmark(async_jobs, ECDSA_verify_loop, loopargs);
2511 mr ? "+R6:%ld:%d:%.2f\n"
2512 : "%ld %d bit ECDSA verify in %.2fs\n",
2513 count, test_curves_bits[testnum], d);
2514 ecdsa_results[testnum][1] = d / (double)count;
2517 if (rsa_count <= 1) {
2518 /* if longer than 10s, don't do any more */
2519 for (testnum++; testnum < EC_NUM; testnum++)
2520 ecdsa_doit[testnum] = 0;
2525 if (RAND_status() != 1) {
2526 RAND_seed(rnd_seed, sizeof rnd_seed);
2528 for (testnum = 0; testnum < EC_NUM; testnum++) {
2529 int ecdh_checks = 1;
2531 if (!ecdh_doit[testnum])
2533 for (i = 0; i < loopargs_len; i++) {
2534 loopargs[i].ecdh_a[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2535 loopargs[i].ecdh_b[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2536 if (loopargs[i].ecdh_a[testnum] == NULL ||
2537 loopargs[i].ecdh_b[testnum] == NULL) {
2542 if (ecdh_checks == 0) {
2543 BIO_printf(bio_err, "ECDH failure.\n");
2544 ERR_print_errors(bio_err);
2547 for (i = 0; i < loopargs_len; i++) {
2548 /* generate two ECDH key pairs */
2549 if (!EC_KEY_generate_key(loopargs[i].ecdh_a[testnum]) ||
2550 !EC_KEY_generate_key(loopargs[i].ecdh_b[testnum])) {
2551 BIO_printf(bio_err, "ECDH key generation failure.\n");
2552 ERR_print_errors(bio_err);
2556 int secret_size_a, secret_size_b;
2558 * If field size is not more than 24 octets, then use SHA-1
2559 * hash of result; otherwise, use result (see section 4.8 of
2560 * draft-ietf-tls-ecc-03.txt).
2562 int field_size = EC_GROUP_get_degree(
2563 EC_KEY_get0_group(loopargs[i].ecdh_a[testnum]));
2565 if (field_size <= 24 * 8) { /* 192 bits */
2566 loopargs[i].outlen = KDF1_SHA1_len;
2567 loopargs[i].kdf = KDF1_SHA1;
2569 loopargs[i].outlen = (field_size + 7) / 8;
2570 loopargs[i].kdf = NULL;
2573 ECDH_compute_key(loopargs[i].secret_a, loopargs[i].outlen,
2574 EC_KEY_get0_public_key(loopargs[i].ecdh_b[testnum]),
2575 loopargs[i].ecdh_a[testnum], loopargs[i].kdf);
2577 ECDH_compute_key(loopargs[i].secret_b, loopargs[i].outlen,
2578 EC_KEY_get0_public_key(loopargs[i].ecdh_a[testnum]),
2579 loopargs[i].ecdh_b[testnum], loopargs[i].kdf);
2580 if (secret_size_a != secret_size_b)
2585 for (k = 0; k < secret_size_a && ecdh_checks == 1; k++) {
2586 if (loopargs[i].secret_a[k] != loopargs[i].secret_b[k])
2590 if (ecdh_checks == 0) {
2591 BIO_printf(bio_err, "ECDH computations don't match.\n");
2592 ERR_print_errors(bio_err);
2598 if (ecdh_checks != 0) {
2599 pkey_print_message("", "ecdh",
2601 test_curves_bits[testnum], ECDH_SECONDS);
2603 count = run_benchmark(async_jobs, ECDH_compute_key_loop, loopargs);
2606 mr ? "+R7:%ld:%d:%.2f\n" :
2607 "%ld %d-bit ECDH ops in %.2fs\n", count,
2608 test_curves_bits[testnum], d);
2609 ecdh_results[testnum][0] = d / (double)count;
2614 if (rsa_count <= 1) {
2615 /* if longer than 10s, don't do any more */
2616 for (testnum++; testnum < EC_NUM; testnum++)
2617 ecdh_doit[testnum] = 0;
2625 printf("%s\n", OpenSSL_version(OPENSSL_VERSION));
2626 printf("%s\n", OpenSSL_version(OPENSSL_BUILT_ON));
2628 printf("%s ", BN_options());
2629 #ifndef OPENSSL_NO_MD2
2630 printf("%s ", MD2_options());
2632 #ifndef OPENSSL_NO_RC4
2633 printf("%s ", RC4_options());
2635 #ifndef OPENSSL_NO_DES
2636 printf("%s ", DES_options());
2638 printf("%s ", AES_options());
2639 #ifndef OPENSSL_NO_IDEA
2640 printf("%s ", IDEA_options());
2642 #ifndef OPENSSL_NO_BF
2643 printf("%s ", BF_options());
2645 printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
2653 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2656 for (testnum = 0; testnum < SIZE_NUM; testnum++)
2657 printf(mr ? ":%d" : "%7d bytes", lengths[testnum]);
2661 for (k = 0; k < ALGOR_NUM; k++) {
2665 printf("+F:%d:%s", k, names[k]);
2667 printf("%-13s", names[k]);
2668 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2669 if (results[k][testnum] > 10000 && !mr)
2670 printf(" %11.2fk", results[k][testnum] / 1e3);
2672 printf(mr ? ":%.2f" : " %11.2f ", results[k][testnum]);
2676 #ifndef OPENSSL_NO_RSA
2678 for (k = 0; k < RSA_NUM; k++) {
2681 if (testnum && !mr) {
2682 printf("%18ssign verify sign/s verify/s\n", " ");
2686 printf("+F2:%u:%u:%f:%f\n",
2687 k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2689 printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2690 rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2691 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2694 #ifndef OPENSSL_NO_DSA
2696 for (k = 0; k < DSA_NUM; k++) {
2699 if (testnum && !mr) {
2700 printf("%18ssign verify sign/s verify/s\n", " ");
2704 printf("+F3:%u:%u:%f:%f\n",
2705 k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2707 printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2708 dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2709 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2712 #ifndef OPENSSL_NO_EC
2714 for (k = 0; k < EC_NUM; k++) {
2717 if (testnum && !mr) {
2718 printf("%30ssign verify sign/s verify/s\n", " ");
2723 printf("+F4:%u:%u:%f:%f\n",
2724 k, test_curves_bits[k],
2725 ecdsa_results[k][0], ecdsa_results[k][1]);
2727 printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2728 test_curves_bits[k],
2729 test_curves_names[k],
2730 ecdsa_results[k][0], ecdsa_results[k][1],
2731 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2735 for (k = 0; k < EC_NUM; k++) {
2738 if (testnum && !mr) {
2739 printf("%30sop op/s\n", " ");
2743 printf("+F5:%u:%u:%f:%f\n",
2744 k, test_curves_bits[k],
2745 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2748 printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2749 test_curves_bits[k],
2750 test_curves_names[k],
2751 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2758 ERR_print_errors(bio_err);
2759 for (i = 0; i < loopargs_len; i++) {
2760 OPENSSL_free(loopargs[i].buf_malloc);
2761 OPENSSL_free(loopargs[i].buf2_malloc);
2762 OPENSSL_free(loopargs[i].siglen);
2764 #ifndef OPENSSL_NO_RSA
2765 for (k = 0; k < RSA_NUM; k++)
2766 RSA_free(loopargs[i].rsa_key[k]);
2768 #ifndef OPENSSL_NO_DSA
2769 for (k = 0; k < DSA_NUM; k++)
2770 DSA_free(loopargs[i].dsa_key[k]);
2772 #ifndef OPENSSL_NO_EC
2773 for (k = 0; k < EC_NUM; k++) {
2774 EC_KEY_free(loopargs[i].ecdsa[k]);
2775 EC_KEY_free(loopargs[i].ecdh_a[k]);
2776 EC_KEY_free(loopargs[i].ecdh_b[k]);
2778 OPENSSL_free(loopargs[i].secret_a);
2779 OPENSSL_free(loopargs[i].secret_b);
2783 if (async_jobs > 0) {
2784 for (i = 0; i < loopargs_len; i++)
2785 ASYNC_WAIT_CTX_free(loopargs[i].wait_ctx);
2789 ASYNC_cleanup_thread();
2791 OPENSSL_free(loopargs);
2795 static void print_message(const char *s, long num, int length)
2799 mr ? "+DT:%s:%d:%d\n"
2800 : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2801 (void)BIO_flush(bio_err);
2805 mr ? "+DN:%s:%ld:%d\n"
2806 : "Doing %s %ld times on %d size blocks: ", s, num, length);
2807 (void)BIO_flush(bio_err);
2811 static void pkey_print_message(const char *str, const char *str2, long num,
2816 mr ? "+DTP:%d:%s:%s:%d\n"
2817 : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2818 (void)BIO_flush(bio_err);
2822 mr ? "+DNP:%ld:%d:%s:%s\n"
2823 : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2824 (void)BIO_flush(bio_err);
2828 static void print_result(int alg, int run_no, int count, double time_used)
2831 BIO_puts(bio_err, "EVP error!\n");
2835 mr ? "+R:%d:%s:%f\n"
2836 : "%d %s's in %.2fs\n", count, names[alg], time_used);
2837 results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2841 static char *sstrsep(char **string, const char *delim)
2844 char *token = *string;
2849 memset(isdelim, 0, sizeof isdelim);
2853 isdelim[(unsigned char)(*delim)] = 1;
2857 while (!isdelim[(unsigned char)(**string)]) {
2869 static int do_multi(int multi)
2874 static char sep[] = ":";
2876 fds = malloc(sizeof(*fds) * multi);
2877 for (n = 0; n < multi; ++n) {
2878 if (pipe(fd) == -1) {
2879 BIO_printf(bio_err, "pipe failure\n");
2883 (void)BIO_flush(bio_err);
2890 if (dup(fd[1]) == -1) {
2891 BIO_printf(bio_err, "dup failed\n");
2900 printf("Forked child %d\n", n);
2903 /* for now, assume the pipe is long enough to take all the output */
2904 for (n = 0; n < multi; ++n) {
2909 f = fdopen(fds[n], "r");
2910 while (fgets(buf, sizeof buf, f)) {
2911 p = strchr(buf, '\n');
2914 if (buf[0] != '+') {
2915 BIO_printf(bio_err, "Don't understand line '%s' from child %d\n",
2919 printf("Got: %s from %d\n", buf, n);
2920 if (strncmp(buf, "+F:", 3) == 0) {
2925 alg = atoi(sstrsep(&p, sep));
2927 for (j = 0; j < SIZE_NUM; ++j)
2928 results[alg][j] += atof(sstrsep(&p, sep));
2929 } else if (strncmp(buf, "+F2:", 4) == 0) {
2934 k = atoi(sstrsep(&p, sep));
2937 d = atof(sstrsep(&p, sep));
2939 rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
2941 rsa_results[k][0] = d;
2943 d = atof(sstrsep(&p, sep));
2945 rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
2947 rsa_results[k][1] = d;
2949 # ifndef OPENSSL_NO_DSA
2950 else if (strncmp(buf, "+F3:", 4) == 0) {
2955 k = atoi(sstrsep(&p, sep));
2958 d = atof(sstrsep(&p, sep));
2960 dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
2962 dsa_results[k][0] = d;
2964 d = atof(sstrsep(&p, sep));
2966 dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
2968 dsa_results[k][1] = d;
2971 # ifndef OPENSSL_NO_EC
2972 else if (strncmp(buf, "+F4:", 4) == 0) {
2977 k = atoi(sstrsep(&p, sep));
2980 d = atof(sstrsep(&p, sep));
2982 ecdsa_results[k][0] =
2983 1 / (1 / ecdsa_results[k][0] + 1 / d);
2985 ecdsa_results[k][0] = d;
2987 d = atof(sstrsep(&p, sep));
2989 ecdsa_results[k][1] =
2990 1 / (1 / ecdsa_results[k][1] + 1 / d);
2992 ecdsa_results[k][1] = d;
2996 # ifndef OPENSSL_NO_EC
2997 else if (strncmp(buf, "+F5:", 4) == 0) {
3002 k = atoi(sstrsep(&p, sep));
3005 d = atof(sstrsep(&p, sep));
3007 ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
3009 ecdh_results[k][0] = d;
3014 else if (strncmp(buf, "+H:", 3) == 0) {
3017 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf, n);
3027 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
3029 static int mblengths[] =
3030 { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
3031 int j, count, num = OSSL_NELEM(mblengths);
3032 const char *alg_name;
3033 unsigned char *inp, *out, no_key[32], no_iv[16];
3034 EVP_CIPHER_CTX *ctx;
3037 inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
3038 out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
3039 ctx = EVP_CIPHER_CTX_new();
3040 EVP_EncryptInit_ex(ctx, evp_cipher, NULL, no_key, no_iv);
3041 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key),
3043 alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
3045 for (j = 0; j < num; j++) {
3046 print_message(alg_name, 0, mblengths[j]);
3048 for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
3049 unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
3050 EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
3051 size_t len = mblengths[j];
3054 memset(aad, 0, 8); /* avoid uninitialized values */
3055 aad[8] = 23; /* SSL3_RT_APPLICATION_DATA */
3056 aad[9] = 3; /* version */
3058 aad[11] = 0; /* length */
3060 mb_param.out = NULL;
3063 mb_param.interleave = 8;
3065 packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
3066 sizeof(mb_param), &mb_param);
3072 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
3073 sizeof(mb_param), &mb_param);
3077 RAND_bytes(out, 16);
3081 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
3082 EVP_AEAD_TLS1_AAD_LEN, aad);
3083 EVP_Cipher(ctx, out, inp, len + pad);
3087 BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
3088 : "%d %s's in %.2fs\n", count, "evp", d);
3089 results[D_EVP][j] = ((double)count) / d * mblengths[j];
3093 fprintf(stdout, "+H");
3094 for (j = 0; j < num; j++)
3095 fprintf(stdout, ":%d", mblengths[j]);
3096 fprintf(stdout, "\n");
3097 fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
3098 for (j = 0; j < num; j++)
3099 fprintf(stdout, ":%.2f", results[D_EVP][j]);
3100 fprintf(stdout, "\n");
3103 "The 'numbers' are in 1000s of bytes per second processed.\n");
3104 fprintf(stdout, "type ");
3105 for (j = 0; j < num; j++)
3106 fprintf(stdout, "%7d bytes", mblengths[j]);
3107 fprintf(stdout, "\n");
3108 fprintf(stdout, "%-24s", alg_name);
3110 for (j = 0; j < num; j++) {
3111 if (results[D_EVP][j] > 10000)
3112 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
3114 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
3116 fprintf(stdout, "\n");
3121 EVP_CIPHER_CTX_free(ctx);