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 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', "Enable async mode and start pnum jobs"},
385 #ifndef OPENSSL_NO_ENGINE
386 {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
401 #define D_CBC_IDEA 10
402 #define D_CBC_SEED 11
406 #define D_CBC_CAST 15
407 #define D_CBC_128_AES 16
408 #define D_CBC_192_AES 17
409 #define D_CBC_256_AES 18
410 #define D_CBC_128_CML 19
411 #define D_CBC_192_CML 20
412 #define D_CBC_256_CML 21
416 #define D_WHIRLPOOL 25
417 #define D_IGE_128_AES 26
418 #define D_IGE_192_AES 27
419 #define D_IGE_256_AES 28
421 static OPT_PAIR doit_choices[] = {
422 #ifndef OPENSSL_NO_MD2
425 #ifndef OPENSSL_NO_MDC2
428 #ifndef OPENSSL_NO_MD4
431 #ifndef OPENSSL_NO_MD5
434 #ifndef OPENSSL_NO_MD5
438 {"sha256", D_SHA256},
439 {"sha512", D_SHA512},
440 #ifndef OPENSSL_NO_WHIRLPOOL
441 {"whirlpool", D_WHIRLPOOL},
443 #ifndef OPENSSL_NO_RMD160
444 {"ripemd", D_RMD160},
445 {"rmd160", D_RMD160},
446 {"ripemd160", D_RMD160},
448 #ifndef OPENSSL_NO_RC4
451 #ifndef OPENSSL_NO_DES
452 {"des-cbc", D_CBC_DES},
453 {"des-ede3", D_EDE3_DES},
455 {"aes-128-cbc", D_CBC_128_AES},
456 {"aes-192-cbc", D_CBC_192_AES},
457 {"aes-256-cbc", D_CBC_256_AES},
458 {"aes-128-ige", D_IGE_128_AES},
459 {"aes-192-ige", D_IGE_192_AES},
460 {"aes-256-ige", D_IGE_256_AES},
461 #ifndef OPENSSL_NO_RC2
462 {"rc2-cbc", D_CBC_RC2},
465 #ifndef OPENSSL_NO_RC5
466 {"rc5-cbc", D_CBC_RC5},
469 #ifndef OPENSSL_NO_IDEA
470 {"idea-cbc", D_CBC_IDEA},
471 {"idea", D_CBC_IDEA},
473 #ifndef OPENSSL_NO_SEED
474 {"seed-cbc", D_CBC_SEED},
475 {"seed", D_CBC_SEED},
477 #ifndef OPENSSL_NO_BF
478 {"bf-cbc", D_CBC_BF},
479 {"blowfish", D_CBC_BF},
482 #ifndef OPENSSL_NO_CAST
483 {"cast-cbc", D_CBC_CAST},
484 {"cast", D_CBC_CAST},
485 {"cast5", D_CBC_CAST},
491 #ifndef OPENSSL_NO_DSA
493 # define R_DSA_1024 1
494 # define R_DSA_2048 2
495 static OPT_PAIR dsa_choices[] = {
496 {"dsa512", R_DSA_512},
497 {"dsa1024", R_DSA_1024},
498 {"dsa2048", R_DSA_2048},
509 #define R_RSA_15360 6
510 static OPT_PAIR rsa_choices[] = {
511 {"rsa512", R_RSA_512},
512 {"rsa1024", R_RSA_1024},
513 {"rsa2048", R_RSA_2048},
514 {"rsa3072", R_RSA_3072},
515 {"rsa4096", R_RSA_4096},
516 {"rsa7680", R_RSA_7680},
517 {"rsa15360", R_RSA_15360},
537 #define R_EC_X25519 16
538 #ifndef OPENSSL_NO_EC
539 static OPT_PAIR ecdsa_choices[] = {
540 {"ecdsap160", R_EC_P160},
541 {"ecdsap192", R_EC_P192},
542 {"ecdsap224", R_EC_P224},
543 {"ecdsap256", R_EC_P256},
544 {"ecdsap384", R_EC_P384},
545 {"ecdsap521", R_EC_P521},
546 {"ecdsak163", R_EC_K163},
547 {"ecdsak233", R_EC_K233},
548 {"ecdsak283", R_EC_K283},
549 {"ecdsak409", R_EC_K409},
550 {"ecdsak571", R_EC_K571},
551 {"ecdsab163", R_EC_B163},
552 {"ecdsab233", R_EC_B233},
553 {"ecdsab283", R_EC_B283},
554 {"ecdsab409", R_EC_B409},
555 {"ecdsab571", R_EC_B571},
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;
1049 int count, outlen = tempargs->outlen;
1050 kdf_fn kdf = tempargs->kdf;
1052 for (count = 0; COND(ecdh_c[testnum][0]); count++) {
1053 ECDH_compute_key(secret_a, outlen,
1054 EC_KEY_get0_public_key(ecdh_b[testnum]),
1055 ecdh_a[testnum], kdf);
1060 static const int KDF1_SHA1_len = 20;
1061 static void *KDF1_SHA1(const void *in, size_t inlen, void *out,
1064 if (*outlen < SHA_DIGEST_LENGTH)
1066 *outlen = SHA_DIGEST_LENGTH;
1067 return SHA1(in, inlen, out);
1070 #endif /* ndef OPENSSL_NO_EC */
1073 static int run_benchmark(int async_jobs, 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, async = 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 async = ASYNC_start_job(&(loopargs[i].inprogress_job), loopargs[i].wait_ctx,
1090 &job_op_count, loop_function,
1091 (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)
1187 async = ASYNC_start_job(&(loopargs[i].inprogress_job), loopargs[i].wait_ctx,
1188 &job_op_count, loop_function, (void *)(loopargs + i),
1189 sizeof(loopargs_t));
1194 if (job_op_count == -1) {
1197 total_op_count += job_op_count;
1200 loopargs[i].inprogress_job = NULL;
1205 loopargs[i].inprogress_job = NULL;
1206 BIO_printf(bio_err, "Failure in the job\n");
1207 ERR_print_errors(bio_err);
1214 return error ? -1 : total_op_count;
1217 int speed_main(int argc, char **argv)
1219 loopargs_t *loopargs = NULL;
1221 int loopargs_len = 0;
1223 #ifndef OPENSSL_NO_ENGINE
1224 const char *engine_id = NULL;
1226 const EVP_CIPHER *evp_cipher = NULL;
1229 int multiblock = 0, pr_header = 0;
1230 int doit[ALGOR_NUM] = { 0 };
1231 int ret = 1, i, k, misalign = 0;
1237 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) \
1238 || !defined(OPENSSL_NO_EC)
1242 /* What follows are the buffers and key material. */
1243 #ifndef OPENSSL_NO_RC5
1246 #ifndef OPENSSL_NO_RC2
1249 #ifndef OPENSSL_NO_IDEA
1250 IDEA_KEY_SCHEDULE idea_ks;
1252 #ifndef OPENSSL_NO_SEED
1253 SEED_KEY_SCHEDULE seed_ks;
1255 #ifndef OPENSSL_NO_BF
1258 #ifndef OPENSSL_NO_CAST
1261 static const unsigned char key16[16] = {
1262 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1263 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1265 static const unsigned char key24[24] = {
1266 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1267 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1268 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1270 static const unsigned char key32[32] = {
1271 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1272 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1273 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1274 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1276 #ifndef OPENSSL_NO_CAMELLIA
1277 static const unsigned char ckey24[24] = {
1278 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1279 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1280 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1282 static const unsigned char ckey32[32] = {
1283 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1284 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1285 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1286 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1288 CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
1290 #ifndef OPENSSL_NO_DES
1291 static DES_cblock key = {
1292 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
1294 static DES_cblock key2 = {
1295 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1297 static DES_cblock key3 = {
1298 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1301 #ifndef OPENSSL_NO_RSA
1302 static const unsigned int rsa_bits[RSA_NUM] = {
1303 512, 1024, 2048, 3072, 4096, 7680, 15360
1305 static const unsigned char *rsa_data[RSA_NUM] = {
1306 test512, test1024, test2048, test3072, test4096, test7680, test15360
1308 static const int rsa_data_length[RSA_NUM] = {
1309 sizeof(test512), sizeof(test1024),
1310 sizeof(test2048), sizeof(test3072),
1311 sizeof(test4096), sizeof(test7680),
1314 int rsa_doit[RSA_NUM] = { 0 };
1316 #ifndef OPENSSL_NO_DSA
1317 static const unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
1318 int dsa_doit[DSA_NUM] = { 0 };
1320 #ifndef OPENSSL_NO_EC
1322 * We only test over the following curves as they are representative, To
1323 * add tests over more curves, simply add the curve NID and curve name to
1324 * the following arrays and increase the EC_NUM value accordingly.
1326 static const unsigned int test_curves[EC_NUM] = {
1328 NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
1329 NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
1331 NID_sect163k1, NID_sect233k1, NID_sect283k1,
1332 NID_sect409k1, NID_sect571k1, NID_sect163r2,
1333 NID_sect233r1, NID_sect283r1, NID_sect409r1,
1338 static const char *test_curves_names[EC_NUM] = {
1340 "secp160r1", "nistp192", "nistp224",
1341 "nistp256", "nistp384", "nistp521",
1343 "nistk163", "nistk233", "nistk283",
1344 "nistk409", "nistk571", "nistb163",
1345 "nistb233", "nistb283", "nistb409",
1350 static const int test_curves_bits[EC_NUM] = {
1356 571, 253 /* X25519 */
1359 int ecdsa_doit[EC_NUM] = { 0 };
1360 int ecdh_doit[EC_NUM] = { 0 };
1361 #endif /* ndef OPENSSL_NO_EC */
1363 prog = opt_init(argc, argv, speed_options);
1364 while ((o = opt_next()) != OPT_EOF) {
1369 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
1372 opt_help(speed_options);
1379 evp_cipher = EVP_get_cipherbyname(opt_arg());
1380 if (evp_cipher == NULL)
1381 evp_md = EVP_get_digestbyname(opt_arg());
1382 if (evp_cipher == NULL && evp_md == NULL) {
1384 "%s: %s is an unknown cipher or digest\n",
1395 * In a forked execution, an engine might need to be
1396 * initialised by each child process, not by the parent.
1397 * So store the name here and run setup_engine() later on.
1399 #ifndef OPENSSL_NO_ENGINE
1400 engine_id = opt_arg();
1405 multi = atoi(opt_arg());
1409 #ifndef OPENSSL_NO_ASYNC
1410 async_jobs = atoi(opt_arg());
1411 if (!ASYNC_is_capable()) {
1413 "%s: async_jobs specified but async not supported\n",
1420 if (!opt_int(opt_arg(), &misalign))
1422 if (misalign > MISALIGN) {
1424 "%s: Maximum offset is %d\n", prog, MISALIGN);
1436 argc = opt_num_rest();
1439 /* Remaining arguments are algorithms. */
1440 for ( ; *argv; argv++) {
1441 if (found(*argv, doit_choices, &i)) {
1445 #ifndef OPENSSL_NO_DES
1446 if (strcmp(*argv, "des") == 0) {
1447 doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
1451 if (strcmp(*argv, "sha") == 0) {
1452 doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
1455 #ifndef OPENSSL_NO_RSA
1457 if (strcmp(*argv, "openssl") == 0) {
1458 RSA_set_default_method(RSA_PKCS1_OpenSSL());
1462 if (strcmp(*argv, "rsa") == 0) {
1463 rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
1464 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
1465 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
1466 rsa_doit[R_RSA_15360] = 1;
1469 if (found(*argv, rsa_choices, &i)) {
1474 #ifndef OPENSSL_NO_DSA
1475 if (strcmp(*argv, "dsa") == 0) {
1476 dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
1477 dsa_doit[R_DSA_2048] = 1;
1480 if (found(*argv, dsa_choices, &i)) {
1485 if (strcmp(*argv, "aes") == 0) {
1486 doit[D_CBC_128_AES] = doit[D_CBC_192_AES] =
1487 doit[D_CBC_256_AES] = 1;
1490 #ifndef OPENSSL_NO_CAMELLIA
1491 if (strcmp(*argv, "camellia") == 0) {
1492 doit[D_CBC_128_CML] = doit[D_CBC_192_CML] =
1493 doit[D_CBC_256_CML] = 1;
1497 #ifndef OPENSSL_NO_EC
1498 if (strcmp(*argv, "ecdsa") == 0) {
1499 for (i = 0; i < EC_NUM; i++)
1503 if (found(*argv, ecdsa_choices, &i)) {
1507 if (strcmp(*argv, "ecdh") == 0) {
1508 for (i = 0; i < EC_NUM; i++)
1512 if (found(*argv, ecdh_choices, &i)) {
1517 BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
1521 /* Initialize the job pool if async mode is enabled */
1522 if (async_jobs > 0) {
1523 async_init = ASYNC_init_thread(async_jobs, async_jobs);
1525 BIO_printf(bio_err, "Error creating the ASYNC job pool\n");
1530 loopargs_len = (async_jobs == 0 ? 1 : async_jobs);
1531 loopargs = app_malloc(loopargs_len * sizeof(loopargs_t), "array of loopargs");
1532 memset(loopargs, 0, loopargs_len * sizeof(loopargs_t));
1534 for (i = 0; i < loopargs_len; i++) {
1535 if (async_jobs > 0) {
1536 loopargs[i].wait_ctx = ASYNC_WAIT_CTX_new();
1537 if (loopargs[i].wait_ctx == NULL) {
1538 BIO_printf(bio_err, "Error creating the ASYNC_WAIT_CTX\n");
1543 loopargs[i].buf_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1544 loopargs[i].buf2_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1545 /* Align the start of buffers on a 64 byte boundary */
1546 loopargs[i].buf = loopargs[i].buf_malloc + misalign;
1547 loopargs[i].buf2 = loopargs[i].buf2_malloc + misalign;
1548 #ifndef OPENSSL_NO_EC
1549 loopargs[i].secret_a = app_malloc(MAX_ECDH_SIZE, "ECDH secret a");
1550 loopargs[i].secret_b = app_malloc(MAX_ECDH_SIZE, "ECDH secret b");
1555 if (multi && do_multi(multi))
1559 /* Initialize the engine after the fork */
1560 (void)setup_engine(engine_id, 0);
1562 /* No parameters; turn on everything. */
1563 if ((argc == 0) && !doit[D_EVP]) {
1564 for (i = 0; i < ALGOR_NUM; i++)
1567 for (i = 0; i < RSA_NUM; i++)
1569 #ifndef OPENSSL_NO_DSA
1570 for (i = 0; i < DSA_NUM; i++)
1573 #ifndef OPENSSL_NO_EC
1574 for (i = 0; i < EC_NUM; i++)
1576 for (i = 0; i < EC_NUM; i++)
1580 for (i = 0; i < ALGOR_NUM; i++)
1584 if (usertime == 0 && !mr)
1586 "You have chosen to measure elapsed time "
1587 "instead of user CPU time.\n");
1589 #ifndef OPENSSL_NO_RSA
1590 for (i = 0; i < loopargs_len; i++) {
1591 for (k = 0; k < RSA_NUM; k++) {
1592 const unsigned char *p;
1595 loopargs[i].rsa_key[k] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[k]);
1596 if (loopargs[i].rsa_key[k] == NULL) {
1597 BIO_printf(bio_err, "internal error loading RSA key number %d\n",
1604 #ifndef OPENSSL_NO_DSA
1605 for (i = 0; i < loopargs_len; i++) {
1606 loopargs[i].dsa_key[0] = get_dsa512();
1607 loopargs[i].dsa_key[1] = get_dsa1024();
1608 loopargs[i].dsa_key[2] = get_dsa2048();
1611 #ifndef OPENSSL_NO_DES
1612 DES_set_key_unchecked(&key, &sch);
1613 DES_set_key_unchecked(&key2, &sch2);
1614 DES_set_key_unchecked(&key3, &sch3);
1616 AES_set_encrypt_key(key16, 128, &aes_ks1);
1617 AES_set_encrypt_key(key24, 192, &aes_ks2);
1618 AES_set_encrypt_key(key32, 256, &aes_ks3);
1619 #ifndef OPENSSL_NO_CAMELLIA
1620 Camellia_set_key(key16, 128, &camellia_ks1);
1621 Camellia_set_key(ckey24, 192, &camellia_ks2);
1622 Camellia_set_key(ckey32, 256, &camellia_ks3);
1624 #ifndef OPENSSL_NO_IDEA
1625 IDEA_set_encrypt_key(key16, &idea_ks);
1627 #ifndef OPENSSL_NO_SEED
1628 SEED_set_key(key16, &seed_ks);
1630 #ifndef OPENSSL_NO_RC4
1631 RC4_set_key(&rc4_ks, 16, key16);
1633 #ifndef OPENSSL_NO_RC2
1634 RC2_set_key(&rc2_ks, 16, key16, 128);
1636 #ifndef OPENSSL_NO_RC5
1637 RC5_32_set_key(&rc5_ks, 16, key16, 12);
1639 #ifndef OPENSSL_NO_BF
1640 BF_set_key(&bf_ks, 16, key16);
1642 #ifndef OPENSSL_NO_CAST
1643 CAST_set_key(&cast_ks, 16, key16);
1646 # ifndef OPENSSL_NO_DES
1647 BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1653 for (it = count; it; it--)
1654 DES_ecb_encrypt((DES_cblock *)loopargs[0].buf,
1655 (DES_cblock *)loopargs[0].buf, &sch, DES_ENCRYPT);
1659 c[D_MD2][0] = count / 10;
1660 c[D_MDC2][0] = count / 10;
1661 c[D_MD4][0] = count;
1662 c[D_MD5][0] = count;
1663 c[D_HMAC][0] = count;
1664 c[D_SHA1][0] = count;
1665 c[D_RMD160][0] = count;
1666 c[D_RC4][0] = count * 5;
1667 c[D_CBC_DES][0] = count;
1668 c[D_EDE3_DES][0] = count / 3;
1669 c[D_CBC_IDEA][0] = count;
1670 c[D_CBC_SEED][0] = count;
1671 c[D_CBC_RC2][0] = count;
1672 c[D_CBC_RC5][0] = count;
1673 c[D_CBC_BF][0] = count;
1674 c[D_CBC_CAST][0] = count;
1675 c[D_CBC_128_AES][0] = count;
1676 c[D_CBC_192_AES][0] = count;
1677 c[D_CBC_256_AES][0] = count;
1678 c[D_CBC_128_CML][0] = count;
1679 c[D_CBC_192_CML][0] = count;
1680 c[D_CBC_256_CML][0] = count;
1681 c[D_SHA256][0] = count;
1682 c[D_SHA512][0] = count;
1683 c[D_WHIRLPOOL][0] = count;
1684 c[D_IGE_128_AES][0] = count;
1685 c[D_IGE_192_AES][0] = count;
1686 c[D_IGE_256_AES][0] = count;
1687 c[D_GHASH][0] = count;
1689 for (i = 1; i < SIZE_NUM; i++) {
1692 l0 = (long)lengths[0];
1693 l1 = (long)lengths[i];
1695 c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1696 c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1697 c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1698 c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1699 c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1700 c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1701 c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1702 c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1703 c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1704 c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1705 c[D_GHASH][i] = c[D_GHASH][0] * 4 * l0 / l1;
1707 l0 = (long)lengths[i - 1];
1709 c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1710 c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1711 c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1712 c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1713 c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1714 c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1715 c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1716 c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1717 c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1718 c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1719 c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1720 c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1721 c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1722 c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1723 c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1724 c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1725 c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1726 c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1729 # ifndef OPENSSL_NO_RSA
1730 rsa_c[R_RSA_512][0] = count / 2000;
1731 rsa_c[R_RSA_512][1] = count / 400;
1732 for (i = 1; i < RSA_NUM; i++) {
1733 rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1734 rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1735 if (rsa_doit[i] <= 1 && rsa_c[i][0] == 0)
1738 if (rsa_c[i][0] == 0) {
1739 rsa_c[i][0] = 1; /* Set minimum iteration Nb to 1. */
1746 # ifndef OPENSSL_NO_DSA
1747 dsa_c[R_DSA_512][0] = count / 1000;
1748 dsa_c[R_DSA_512][1] = count / 1000 / 2;
1749 for (i = 1; i < DSA_NUM; i++) {
1750 dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1751 dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1752 if (dsa_doit[i] <= 1 && dsa_c[i][0] == 0)
1755 if (dsa_c[i][0] == 0) {
1756 dsa_c[i][0] = 1; /* Set minimum iteration Nb to 1. */
1763 # ifndef OPENSSL_NO_EC
1764 ecdsa_c[R_EC_P160][0] = count / 1000;
1765 ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1766 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1767 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1768 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1769 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1772 if (ecdsa_c[i][0] == 0) {
1778 ecdsa_c[R_EC_K163][0] = count / 1000;
1779 ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1780 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1781 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1782 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1783 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1786 if (ecdsa_c[i][0] == 0) {
1792 ecdsa_c[R_EC_B163][0] = count / 1000;
1793 ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1794 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1795 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1796 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1797 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1800 if (ecdsa_c[i][0] == 0) {
1807 ecdh_c[R_EC_P160][0] = count / 1000;
1808 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1809 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1810 if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1813 if (ecdh_c[i][0] == 0) {
1818 ecdh_c[R_EC_K163][0] = count / 1000;
1819 for (i = R_EC_K233; i <= R_EC_K571; 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_B163][0] = count / 1000;
1830 for (i = R_EC_B233; i <= R_EC_B571; 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) {
1843 /* not worth fixing */
1844 # error "You cannot disable DES on systems without SIGALRM."
1845 # endif /* OPENSSL_NO_DES */
1848 signal(SIGALRM, sig_done);
1850 #endif /* SIGALRM */
1852 #ifndef OPENSSL_NO_MD2
1854 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1855 print_message(names[D_MD2], c[D_MD2][testnum], lengths[testnum]);
1857 count = run_benchmark(async_jobs, EVP_Digest_MD2_loop, loopargs);
1859 print_result(D_MD2, testnum, count, d);
1863 #ifndef OPENSSL_NO_MDC2
1865 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1866 print_message(names[D_MDC2], c[D_MDC2][testnum], lengths[testnum]);
1868 count = run_benchmark(async_jobs, EVP_Digest_MDC2_loop, loopargs);
1870 print_result(D_MDC2, testnum, count, d);
1875 #ifndef OPENSSL_NO_MD4
1877 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1878 print_message(names[D_MD4], c[D_MD4][testnum], lengths[testnum]);
1880 count = run_benchmark(async_jobs, EVP_Digest_MD4_loop, loopargs);
1882 print_result(D_MD4, testnum, count, d);
1887 #ifndef OPENSSL_NO_MD5
1889 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1890 print_message(names[D_MD5], c[D_MD5][testnum], lengths[testnum]);
1892 count = run_benchmark(async_jobs, MD5_loop, loopargs);
1894 print_result(D_MD5, testnum, count, d);
1899 #ifndef OPENSSL_NO_MD5
1901 char hmac_key[] = "This is a key...";
1902 int len = strlen(hmac_key);
1904 for (i = 0; i < loopargs_len; i++) {
1905 loopargs[i].hctx = HMAC_CTX_new();
1906 if (loopargs[i].hctx == NULL) {
1907 BIO_printf(bio_err, "HMAC malloc failure, exiting...");
1911 HMAC_Init_ex(loopargs[i].hctx, hmac_key, len, EVP_md5(), NULL);
1913 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1914 print_message(names[D_HMAC], c[D_HMAC][testnum], lengths[testnum]);
1916 count = run_benchmark(async_jobs, HMAC_loop, loopargs);
1918 print_result(D_HMAC, testnum, count, d);
1920 for (i = 0; i < loopargs_len; i++) {
1921 HMAC_CTX_free(loopargs[i].hctx);
1926 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1927 print_message(names[D_SHA1], c[D_SHA1][testnum], lengths[testnum]);
1929 count = run_benchmark(async_jobs, SHA1_loop, loopargs);
1931 print_result(D_SHA1, testnum, count, d);
1934 if (doit[D_SHA256]) {
1935 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1936 print_message(names[D_SHA256], c[D_SHA256][testnum], lengths[testnum]);
1938 count = run_benchmark(async_jobs, SHA256_loop, loopargs);
1940 print_result(D_SHA256, testnum, count, d);
1943 if (doit[D_SHA512]) {
1944 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1945 print_message(names[D_SHA512], c[D_SHA512][testnum], lengths[testnum]);
1947 count = run_benchmark(async_jobs, SHA512_loop, loopargs);
1949 print_result(D_SHA512, testnum, count, d);
1953 #ifndef OPENSSL_NO_WHIRLPOOL
1954 if (doit[D_WHIRLPOOL]) {
1955 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1956 print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][testnum], lengths[testnum]);
1958 count = run_benchmark(async_jobs, WHIRLPOOL_loop, loopargs);
1960 print_result(D_WHIRLPOOL, testnum, count, d);
1965 #ifndef OPENSSL_NO_RMD160
1966 if (doit[D_RMD160]) {
1967 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1968 print_message(names[D_RMD160], c[D_RMD160][testnum], lengths[testnum]);
1970 count = run_benchmark(async_jobs, EVP_Digest_RMD160_loop, loopargs);
1972 print_result(D_RMD160, testnum, count, d);
1976 #ifndef OPENSSL_NO_RC4
1978 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1979 print_message(names[D_RC4], c[D_RC4][testnum], lengths[testnum]);
1981 count = run_benchmark(async_jobs, RC4_loop, loopargs);
1983 print_result(D_RC4, testnum, count, d);
1987 #ifndef OPENSSL_NO_DES
1988 if (doit[D_CBC_DES]) {
1989 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1990 print_message(names[D_CBC_DES], c[D_CBC_DES][testnum], lengths[testnum]);
1992 count = run_benchmark(async_jobs, DES_ncbc_encrypt_loop, loopargs);
1994 print_result(D_CBC_DES, testnum, count, d);
1998 if (doit[D_EDE3_DES]) {
1999 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2000 print_message(names[D_EDE3_DES], c[D_EDE3_DES][testnum], lengths[testnum]);
2002 count = run_benchmark(async_jobs, DES_ede3_cbc_encrypt_loop, loopargs);
2004 print_result(D_EDE3_DES, testnum, count, d);
2009 if (doit[D_CBC_128_AES]) {
2010 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2011 print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][testnum],
2014 count = run_benchmark(async_jobs, AES_cbc_128_encrypt_loop, loopargs);
2016 print_result(D_CBC_128_AES, testnum, count, d);
2019 if (doit[D_CBC_192_AES]) {
2020 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2021 print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][testnum],
2024 count = run_benchmark(async_jobs, AES_cbc_192_encrypt_loop, loopargs);
2026 print_result(D_CBC_192_AES, testnum, count, d);
2029 if (doit[D_CBC_256_AES]) {
2030 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2031 print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][testnum],
2034 count = run_benchmark(async_jobs, AES_cbc_256_encrypt_loop, loopargs);
2036 print_result(D_CBC_256_AES, testnum, count, d);
2040 if (doit[D_IGE_128_AES]) {
2041 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2042 print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][testnum],
2045 count = run_benchmark(async_jobs, AES_ige_128_encrypt_loop, loopargs);
2047 print_result(D_IGE_128_AES, testnum, count, d);
2050 if (doit[D_IGE_192_AES]) {
2051 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2052 print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][testnum],
2055 count = run_benchmark(async_jobs, AES_ige_192_encrypt_loop, loopargs);
2057 print_result(D_IGE_192_AES, testnum, count, d);
2060 if (doit[D_IGE_256_AES]) {
2061 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2062 print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][testnum],
2065 count = run_benchmark(async_jobs, AES_ige_256_encrypt_loop, loopargs);
2067 print_result(D_IGE_256_AES, testnum, count, d);
2070 if (doit[D_GHASH]) {
2071 for (i = 0; i < loopargs_len; i++) {
2072 loopargs[i].gcm_ctx = CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
2073 CRYPTO_gcm128_setiv(loopargs[i].gcm_ctx, (unsigned char *)"0123456789ab", 12);
2076 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2077 print_message(names[D_GHASH], c[D_GHASH][testnum], lengths[testnum]);
2079 count = run_benchmark(async_jobs, CRYPTO_gcm128_aad_loop, loopargs);
2081 print_result(D_GHASH, testnum, count, d);
2083 for (i = 0; i < loopargs_len; i++)
2084 CRYPTO_gcm128_release(loopargs[i].gcm_ctx);
2087 #ifndef OPENSSL_NO_CAMELLIA
2088 if (doit[D_CBC_128_CML]) {
2089 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2090 print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][testnum],
2092 if (async_jobs > 0) {
2093 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2097 for (count = 0, run = 1; COND(c[D_CBC_128_CML][testnum]); count++)
2098 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2099 (size_t)lengths[testnum], &camellia_ks1,
2100 iv, CAMELLIA_ENCRYPT);
2102 print_result(D_CBC_128_CML, testnum, count, d);
2105 if (doit[D_CBC_192_CML]) {
2106 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2107 print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][testnum],
2109 if (async_jobs > 0) {
2110 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2114 for (count = 0, run = 1; COND(c[D_CBC_192_CML][testnum]); count++)
2115 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2116 (size_t)lengths[testnum], &camellia_ks2,
2117 iv, CAMELLIA_ENCRYPT);
2119 print_result(D_CBC_192_CML, testnum, count, d);
2122 if (doit[D_CBC_256_CML]) {
2123 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2124 print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][testnum],
2126 if (async_jobs > 0) {
2127 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2131 for (count = 0, run = 1; COND(c[D_CBC_256_CML][testnum]); count++)
2132 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2133 (size_t)lengths[testnum], &camellia_ks3,
2134 iv, CAMELLIA_ENCRYPT);
2136 print_result(D_CBC_256_CML, testnum, count, d);
2140 #ifndef OPENSSL_NO_IDEA
2141 if (doit[D_CBC_IDEA]) {
2142 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2143 print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][testnum], lengths[testnum]);
2144 if (async_jobs > 0) {
2145 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2149 for (count = 0, run = 1; COND(c[D_CBC_IDEA][testnum]); count++)
2150 IDEA_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2151 (size_t)lengths[testnum], &idea_ks,
2154 print_result(D_CBC_IDEA, testnum, count, d);
2158 #ifndef OPENSSL_NO_SEED
2159 if (doit[D_CBC_SEED]) {
2160 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2161 print_message(names[D_CBC_SEED], c[D_CBC_SEED][testnum], lengths[testnum]);
2162 if (async_jobs > 0) {
2163 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2167 for (count = 0, run = 1; COND(c[D_CBC_SEED][testnum]); count++)
2168 SEED_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2169 (size_t)lengths[testnum], &seed_ks, iv, 1);
2171 print_result(D_CBC_SEED, testnum, count, d);
2175 #ifndef OPENSSL_NO_RC2
2176 if (doit[D_CBC_RC2]) {
2177 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2178 print_message(names[D_CBC_RC2], c[D_CBC_RC2][testnum], lengths[testnum]);
2179 if (async_jobs > 0) {
2180 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2184 for (count = 0, run = 1; COND(c[D_CBC_RC2][testnum]); count++)
2185 RC2_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2186 (size_t)lengths[testnum], &rc2_ks,
2189 print_result(D_CBC_RC2, testnum, count, d);
2193 #ifndef OPENSSL_NO_RC5
2194 if (doit[D_CBC_RC5]) {
2195 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2196 print_message(names[D_CBC_RC5], c[D_CBC_RC5][testnum], lengths[testnum]);
2197 if (async_jobs > 0) {
2198 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2202 for (count = 0, run = 1; COND(c[D_CBC_RC5][testnum]); count++)
2203 RC5_32_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2204 (size_t)lengths[testnum], &rc5_ks,
2207 print_result(D_CBC_RC5, testnum, count, d);
2211 #ifndef OPENSSL_NO_BF
2212 if (doit[D_CBC_BF]) {
2213 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2214 print_message(names[D_CBC_BF], c[D_CBC_BF][testnum], lengths[testnum]);
2215 if (async_jobs > 0) {
2216 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2220 for (count = 0, run = 1; COND(c[D_CBC_BF][testnum]); count++)
2221 BF_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2222 (size_t)lengths[testnum], &bf_ks,
2225 print_result(D_CBC_BF, testnum, count, d);
2229 #ifndef OPENSSL_NO_CAST
2230 if (doit[D_CBC_CAST]) {
2231 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2232 print_message(names[D_CBC_CAST], c[D_CBC_CAST][testnum], lengths[testnum]);
2233 if (async_jobs > 0) {
2234 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2238 for (count = 0, run = 1; COND(c[D_CBC_CAST][testnum]); count++)
2239 CAST_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2240 (size_t)lengths[testnum], &cast_ks,
2243 print_result(D_CBC_CAST, testnum, count, d);
2249 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
2250 if (multiblock && evp_cipher) {
2252 (EVP_CIPHER_flags(evp_cipher) &
2253 EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
2254 BIO_printf(bio_err, "%s is not multi-block capable\n",
2255 OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
2258 if (async_jobs > 0) {
2259 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2262 multiblock_speed(evp_cipher);
2267 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2270 names[D_EVP] = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
2272 * -O3 -fschedule-insns messes up an optimization here!
2273 * names[D_EVP] somehow becomes NULL
2275 print_message(names[D_EVP], save_count, lengths[testnum]);
2277 for (k = 0; k < loopargs_len; k++) {
2278 loopargs[k].ctx = EVP_CIPHER_CTX_new();
2280 EVP_DecryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2282 EVP_EncryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2283 EVP_CIPHER_CTX_set_padding(loopargs[k].ctx, 0);
2287 count = run_benchmark(async_jobs, EVP_Update_loop, loopargs);
2289 for (k = 0; k < loopargs_len; k++) {
2290 EVP_CIPHER_CTX_free(loopargs[k].ctx);
2294 names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
2295 print_message(names[D_EVP], save_count, lengths[testnum]);
2297 count = run_benchmark(async_jobs, EVP_Digest_loop, loopargs);
2300 print_result(D_EVP, testnum, count, d);
2304 for (i = 0; i < loopargs_len; i++)
2305 RAND_bytes(loopargs[i].buf, 36);
2307 #ifndef OPENSSL_NO_RSA
2308 for (testnum = 0; testnum < RSA_NUM; testnum++) {
2310 if (!rsa_doit[testnum])
2312 for (i = 0; i < loopargs_len; i++) {
2313 st = RSA_sign(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2314 &loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2320 "RSA sign failure. No RSA sign will be done.\n");
2321 ERR_print_errors(bio_err);
2324 pkey_print_message("private", "rsa",
2325 rsa_c[testnum][0], rsa_bits[testnum], RSA_SECONDS);
2326 /* RSA_blinding_on(rsa_key[testnum],NULL); */
2328 count = run_benchmark(async_jobs, RSA_sign_loop, loopargs);
2331 mr ? "+R1:%ld:%d:%.2f\n"
2332 : "%ld %d bit private RSA's in %.2fs\n",
2333 count, rsa_bits[testnum], d);
2334 rsa_results[testnum][0] = d / (double)count;
2338 for (i = 0; i < loopargs_len; i++) {
2339 st = RSA_verify(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2340 loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2346 "RSA verify failure. No RSA verify will be done.\n");
2347 ERR_print_errors(bio_err);
2348 rsa_doit[testnum] = 0;
2350 pkey_print_message("public", "rsa",
2351 rsa_c[testnum][1], rsa_bits[testnum], RSA_SECONDS);
2353 count = run_benchmark(async_jobs, RSA_verify_loop, loopargs);
2356 mr ? "+R2:%ld:%d:%.2f\n"
2357 : "%ld %d bit public RSA's in %.2fs\n",
2358 count, rsa_bits[testnum], d);
2359 rsa_results[testnum][1] = d / (double)count;
2362 if (rsa_count <= 1) {
2363 /* if longer than 10s, don't do any more */
2364 for (testnum++; testnum < RSA_NUM; testnum++)
2365 rsa_doit[testnum] = 0;
2370 for (i = 0; i < loopargs_len; i++)
2371 RAND_bytes(loopargs[i].buf, 36);
2373 #ifndef OPENSSL_NO_DSA
2374 if (RAND_status() != 1) {
2375 RAND_seed(rnd_seed, sizeof rnd_seed);
2377 for (testnum = 0; testnum < DSA_NUM; testnum++) {
2379 if (!dsa_doit[testnum])
2382 /* DSA_generate_key(dsa_key[testnum]); */
2383 /* DSA_sign_setup(dsa_key[testnum],NULL); */
2384 for (i = 0; i < loopargs_len; i++) {
2385 st = DSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2386 &loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2392 "DSA sign failure. No DSA sign will be done.\n");
2393 ERR_print_errors(bio_err);
2396 pkey_print_message("sign", "dsa",
2397 dsa_c[testnum][0], dsa_bits[testnum], DSA_SECONDS);
2399 count = run_benchmark(async_jobs, DSA_sign_loop, loopargs);
2402 mr ? "+R3:%ld:%d:%.2f\n"
2403 : "%ld %d bit DSA signs in %.2fs\n",
2404 count, dsa_bits[testnum], d);
2405 dsa_results[testnum][0] = d / (double)count;
2409 for (i = 0; i < loopargs_len; i++) {
2410 st = DSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2411 loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2417 "DSA verify failure. No DSA verify will be done.\n");
2418 ERR_print_errors(bio_err);
2419 dsa_doit[testnum] = 0;
2421 pkey_print_message("verify", "dsa",
2422 dsa_c[testnum][1], dsa_bits[testnum], DSA_SECONDS);
2424 count = run_benchmark(async_jobs, DSA_verify_loop, loopargs);
2427 mr ? "+R4:%ld:%d:%.2f\n"
2428 : "%ld %d bit DSA verify in %.2fs\n",
2429 count, dsa_bits[testnum], d);
2430 dsa_results[testnum][1] = d / (double)count;
2433 if (rsa_count <= 1) {
2434 /* if longer than 10s, don't do any more */
2435 for (testnum++; testnum < DSA_NUM; testnum++)
2436 dsa_doit[testnum] = 0;
2441 #ifndef OPENSSL_NO_EC
2442 if (RAND_status() != 1) {
2443 RAND_seed(rnd_seed, sizeof rnd_seed);
2445 for (testnum = 0; testnum < EC_NUM; testnum++) {
2448 if (!ecdsa_doit[testnum])
2449 continue; /* Ignore Curve */
2450 for (i = 0; i < loopargs_len; i++) {
2451 loopargs[i].ecdsa[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2452 if (loopargs[i].ecdsa[testnum] == NULL) {
2458 BIO_printf(bio_err, "ECDSA failure.\n");
2459 ERR_print_errors(bio_err);
2462 for (i = 0; i < loopargs_len; i++) {
2463 EC_KEY_precompute_mult(loopargs[i].ecdsa[testnum], NULL);
2464 /* Perform ECDSA signature test */
2465 EC_KEY_generate_key(loopargs[i].ecdsa[testnum]);
2466 st = ECDSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2467 &loopargs[i].siglen, loopargs[i].ecdsa[testnum]);
2473 "ECDSA sign failure. No ECDSA sign will be done.\n");
2474 ERR_print_errors(bio_err);
2477 pkey_print_message("sign", "ecdsa",
2478 ecdsa_c[testnum][0],
2479 test_curves_bits[testnum], ECDSA_SECONDS);
2481 count = run_benchmark(async_jobs, ECDSA_sign_loop, loopargs);
2485 mr ? "+R5:%ld:%d:%.2f\n" :
2486 "%ld %d bit ECDSA signs in %.2fs \n",
2487 count, test_curves_bits[testnum], d);
2488 ecdsa_results[testnum][0] = d / (double)count;
2492 /* Perform ECDSA verification test */
2493 for (i = 0; i < loopargs_len; i++) {
2494 st = ECDSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2495 loopargs[i].siglen, loopargs[i].ecdsa[testnum]);
2501 "ECDSA verify failure. No ECDSA verify will be done.\n");
2502 ERR_print_errors(bio_err);
2503 ecdsa_doit[testnum] = 0;
2505 pkey_print_message("verify", "ecdsa",
2506 ecdsa_c[testnum][1],
2507 test_curves_bits[testnum], ECDSA_SECONDS);
2509 count = run_benchmark(async_jobs, ECDSA_verify_loop, loopargs);
2512 mr ? "+R6:%ld:%d:%.2f\n"
2513 : "%ld %d bit ECDSA verify in %.2fs\n",
2514 count, test_curves_bits[testnum], d);
2515 ecdsa_results[testnum][1] = d / (double)count;
2518 if (rsa_count <= 1) {
2519 /* if longer than 10s, don't do any more */
2520 for (testnum++; testnum < EC_NUM; testnum++)
2521 ecdsa_doit[testnum] = 0;
2526 if (RAND_status() != 1) {
2527 RAND_seed(rnd_seed, sizeof rnd_seed);
2529 for (testnum = 0; testnum < EC_NUM; testnum++) {
2530 int ecdh_checks = 1;
2532 if (!ecdh_doit[testnum])
2534 for (i = 0; i < loopargs_len; i++) {
2535 loopargs[i].ecdh_a[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2536 loopargs[i].ecdh_b[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2537 if (loopargs[i].ecdh_a[testnum] == NULL ||
2538 loopargs[i].ecdh_b[testnum] == NULL) {
2543 if (ecdh_checks == 0) {
2544 BIO_printf(bio_err, "ECDH failure.\n");
2545 ERR_print_errors(bio_err);
2548 for (i = 0; i < loopargs_len; i++) {
2549 /* generate two ECDH key pairs */
2550 if (!EC_KEY_generate_key(loopargs[i].ecdh_a[testnum]) ||
2551 !EC_KEY_generate_key(loopargs[i].ecdh_b[testnum])) {
2552 BIO_printf(bio_err, "ECDH key generation failure.\n");
2553 ERR_print_errors(bio_err);
2557 int secret_size_a, secret_size_b;
2559 * If field size is not more than 24 octets, then use SHA-1
2560 * hash of result; otherwise, use result (see section 4.8 of
2561 * draft-ietf-tls-ecc-03.txt).
2563 int field_size = EC_GROUP_get_degree(
2564 EC_KEY_get0_group(loopargs[i].ecdh_a[testnum]));
2566 if (field_size <= 24 * 8) { /* 192 bits */
2567 loopargs[i].outlen = KDF1_SHA1_len;
2568 loopargs[i].kdf = KDF1_SHA1;
2570 loopargs[i].outlen = (field_size + 7) / 8;
2571 loopargs[i].kdf = NULL;
2574 ECDH_compute_key(loopargs[i].secret_a, loopargs[i].outlen,
2575 EC_KEY_get0_public_key(loopargs[i].ecdh_b[testnum]),
2576 loopargs[i].ecdh_a[testnum], loopargs[i].kdf);
2578 ECDH_compute_key(loopargs[i].secret_b, loopargs[i].outlen,
2579 EC_KEY_get0_public_key(loopargs[i].ecdh_a[testnum]),
2580 loopargs[i].ecdh_b[testnum], loopargs[i].kdf);
2581 if (secret_size_a != secret_size_b)
2586 for (k = 0; k < secret_size_a && ecdh_checks == 1; k++) {
2587 if (loopargs[i].secret_a[k] != loopargs[i].secret_b[k])
2591 if (ecdh_checks == 0) {
2592 BIO_printf(bio_err, "ECDH computations don't match.\n");
2593 ERR_print_errors(bio_err);
2599 if (ecdh_checks != 0) {
2600 pkey_print_message("", "ecdh",
2602 test_curves_bits[testnum], ECDH_SECONDS);
2604 count = run_benchmark(async_jobs, ECDH_compute_key_loop, loopargs);
2607 mr ? "+R7:%ld:%d:%.2f\n" :
2608 "%ld %d-bit ECDH ops in %.2fs\n", count,
2609 test_curves_bits[testnum], d);
2610 ecdh_results[testnum][0] = d / (double)count;
2615 if (rsa_count <= 1) {
2616 /* if longer than 10s, don't do any more */
2617 for (testnum++; testnum < EC_NUM; testnum++)
2618 ecdh_doit[testnum] = 0;
2626 printf("%s\n", OpenSSL_version(OPENSSL_VERSION));
2627 printf("%s\n", OpenSSL_version(OPENSSL_BUILT_ON));
2629 printf("%s ", BN_options());
2630 #ifndef OPENSSL_NO_MD2
2631 printf("%s ", MD2_options());
2633 #ifndef OPENSSL_NO_RC4
2634 printf("%s ", RC4_options());
2636 #ifndef OPENSSL_NO_DES
2637 printf("%s ", DES_options());
2639 printf("%s ", AES_options());
2640 #ifndef OPENSSL_NO_IDEA
2641 printf("%s ", IDEA_options());
2643 #ifndef OPENSSL_NO_BF
2644 printf("%s ", BF_options());
2646 printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
2654 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2657 for (testnum = 0; testnum < SIZE_NUM; testnum++)
2658 printf(mr ? ":%d" : "%7d bytes", lengths[testnum]);
2662 for (k = 0; k < ALGOR_NUM; k++) {
2666 printf("+F:%d:%s", k, names[k]);
2668 printf("%-13s", names[k]);
2669 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2670 if (results[k][testnum] > 10000 && !mr)
2671 printf(" %11.2fk", results[k][testnum] / 1e3);
2673 printf(mr ? ":%.2f" : " %11.2f ", results[k][testnum]);
2677 #ifndef OPENSSL_NO_RSA
2679 for (k = 0; k < RSA_NUM; k++) {
2682 if (testnum && !mr) {
2683 printf("%18ssign verify sign/s verify/s\n", " ");
2687 printf("+F2:%u:%u:%f:%f\n",
2688 k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2690 printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2691 rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2692 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2695 #ifndef OPENSSL_NO_DSA
2697 for (k = 0; k < DSA_NUM; k++) {
2700 if (testnum && !mr) {
2701 printf("%18ssign verify sign/s verify/s\n", " ");
2705 printf("+F3:%u:%u:%f:%f\n",
2706 k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2708 printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2709 dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2710 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2713 #ifndef OPENSSL_NO_EC
2715 for (k = 0; k < EC_NUM; k++) {
2718 if (testnum && !mr) {
2719 printf("%30ssign verify sign/s verify/s\n", " ");
2724 printf("+F4:%u:%u:%f:%f\n",
2725 k, test_curves_bits[k],
2726 ecdsa_results[k][0], ecdsa_results[k][1]);
2728 printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2729 test_curves_bits[k],
2730 test_curves_names[k],
2731 ecdsa_results[k][0], ecdsa_results[k][1],
2732 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2736 for (k = 0; k < EC_NUM; k++) {
2739 if (testnum && !mr) {
2740 printf("%30sop op/s\n", " ");
2744 printf("+F5:%u:%u:%f:%f\n",
2745 k, test_curves_bits[k],
2746 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2749 printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2750 test_curves_bits[k],
2751 test_curves_names[k],
2752 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2759 ERR_print_errors(bio_err);
2760 for (i = 0; i < loopargs_len; i++) {
2761 OPENSSL_free(loopargs[i].buf_malloc);
2762 OPENSSL_free(loopargs[i].buf2_malloc);
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);