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 struct loopargs_st {
148 ASYNC_JOB *inprogress_job;
149 ASYNC_WAIT_CTX *wait_ctx;
152 unsigned char *buf_malloc;
153 unsigned char *buf2_malloc;
154 unsigned int *siglen;
155 #ifndef OPENSSL_NO_RSA
156 RSA *rsa_key[RSA_NUM];
158 #ifndef OPENSSL_NO_DSA
159 DSA *dsa_key[DSA_NUM];
161 #ifndef OPENSSL_NO_EC
162 EC_KEY *ecdsa[EC_NUM];
163 EC_KEY *ecdh_a[EC_NUM];
164 EC_KEY *ecdh_b[EC_NUM];
165 unsigned char *secret_a;
166 unsigned char *secret_b;
170 GCM128_CONTEXT *gcm_ctx;
173 #ifndef OPENSSL_NO_MD2
174 static int EVP_Digest_MD2_loop(void *args);
177 #ifndef OPENSSL_NO_MDC2
178 static int EVP_Digest_MDC2_loop(void *args);
180 #ifndef OPENSSL_NO_MD4
181 static int EVP_Digest_MD4_loop(void *args);
183 #ifndef OPENSSL_NO_MD5
184 static int MD5_loop(void *args);
185 static int HMAC_loop(void *args);
187 static int SHA1_loop(void *args);
188 static int SHA256_loop(void *args);
189 static int SHA512_loop(void *args);
190 #ifndef OPENSSL_NO_WHIRLPOOL
191 static int WHIRLPOOL_loop(void *args);
193 #ifndef OPENSSL_NO_RMD160
194 static int EVP_Digest_RMD160_loop(void *args);
196 #ifndef OPENSSL_NO_RC4
197 static int RC4_loop(void *args);
199 #ifndef OPENSSL_NO_DES
200 static int DES_ncbc_encrypt_loop(void *args);
201 static int DES_ede3_cbc_encrypt_loop(void *args);
203 static int AES_cbc_128_encrypt_loop(void *args);
204 static int AES_cbc_192_encrypt_loop(void *args);
205 static int AES_ige_128_encrypt_loop(void *args);
206 static int AES_cbc_256_encrypt_loop(void *args);
207 static int AES_ige_192_encrypt_loop(void *args);
208 static int AES_ige_256_encrypt_loop(void *args);
209 static int CRYPTO_gcm128_aad_loop(void *args);
210 static int EVP_Update_loop(void *args);
211 static int EVP_Digest_loop(void *args);
212 #ifndef OPENSSL_NO_RSA
213 static int RSA_sign_loop(void *args);
214 static int RSA_verify_loop(void *args);
216 #ifndef OPENSSL_NO_DSA
217 static int DSA_sign_loop(void *args);
218 static int DSA_verify_loop(void *args);
220 #ifndef OPENSSL_NO_EC
221 static int ECDSA_sign_loop(void *args);
222 static int ECDSA_verify_loop(void *args);
223 static int ECDH_compute_key_loop(void *args);
225 static int run_benchmark(int async_jobs, int (*loop_function)(void *), loopargs_t *loopargs);
227 static double Time_F(int s);
228 static void print_message(const char *s, long num, int length);
229 static void pkey_print_message(const char *str, const char *str2,
230 long num, int bits, int sec);
231 static void print_result(int alg, int run_no, int count, double time_used);
233 static int do_multi(int multi);
236 static const char *names[ALGOR_NUM] = {
237 "md2", "mdc2", "md4", "md5", "hmac(md5)", "sha1", "rmd160", "rc4",
238 "des cbc", "des ede3", "idea cbc", "seed cbc",
239 "rc2 cbc", "rc5-32/12 cbc", "blowfish cbc", "cast cbc",
240 "aes-128 cbc", "aes-192 cbc", "aes-256 cbc",
241 "camellia-128 cbc", "camellia-192 cbc", "camellia-256 cbc",
242 "evp", "sha256", "sha512", "whirlpool",
243 "aes-128 ige", "aes-192 ige", "aes-256 ige", "ghash"
246 static double results[ALGOR_NUM][SIZE_NUM];
247 static int lengths[SIZE_NUM] = {
248 16, 64, 256, 1024, 8 * 1024, 16 * 1024
251 #ifndef OPENSSL_NO_RSA
252 static double rsa_results[RSA_NUM][2];
254 #ifndef OPENSSL_NO_DSA
255 static double dsa_results[DSA_NUM][2];
257 #ifndef OPENSSL_NO_EC
258 static double ecdsa_results[EC_NUM][2];
259 static double ecdh_results[EC_NUM][1];
262 #if !defined(OPENSSL_NO_DSA) || !defined(OPENSSL_NO_EC)
263 static const char rnd_seed[] =
264 "string to make the random number generator think it has entropy";
268 # if defined(__STDC__) || defined(sgi) || defined(_AIX)
269 # define SIGRETTYPE void
271 # define SIGRETTYPE int
274 static SIGRETTYPE sig_done(int sig);
275 static SIGRETTYPE sig_done(int sig)
277 signal(SIGALRM, sig_done);
287 # if !defined(SIGALRM)
290 static unsigned int lapse, schlock;
291 static void alarm_win32(unsigned int secs)
296 # define alarm alarm_win32
298 static DWORD WINAPI sleepy(VOID * arg)
306 static double Time_F(int s)
313 thr = CreateThread(NULL, 4096, sleepy, NULL, 0, NULL);
315 DWORD err = GetLastError();
316 BIO_printf(bio_err, "unable to CreateThread (%lu)", err);
320 Sleep(0); /* scheduler spinlock */
321 ret = app_tminterval(s, usertime);
323 ret = app_tminterval(s, usertime);
325 TerminateThread(thr, 0);
333 static double Time_F(int s)
335 double ret = app_tminterval(s, usertime);
342 #ifndef OPENSSL_NO_EC
343 static const int KDF1_SHA1_len = 20;
344 static void *KDF1_SHA1(const void *in, size_t inlen, void *out,
347 if (*outlen < SHA_DIGEST_LENGTH)
349 *outlen = SHA_DIGEST_LENGTH;
350 return SHA1(in, inlen, out);
352 #endif /* OPENSSL_NO_EC */
354 static void multiblock_speed(const EVP_CIPHER *evp_cipher);
356 static int found(const char *name, const OPT_PAIR * pairs, int *result)
358 for (; pairs->name; pairs++)
359 if (strcmp(name, pairs->name) == 0) {
360 *result = pairs->retval;
366 typedef enum OPTION_choice {
367 OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
368 OPT_ELAPSED, OPT_EVP, OPT_DECRYPT, OPT_ENGINE, OPT_MULTI,
369 OPT_MR, OPT_MB, OPT_MISALIGN, OPT_ASYNCJOBS
372 OPTIONS speed_options[] = {
373 {OPT_HELP_STR, 1, '-', "Usage: %s [options] ciphers...\n"},
374 {OPT_HELP_STR, 1, '-', "Valid options are:\n"},
375 {"help", OPT_HELP, '-', "Display this summary"},
376 {"evp", OPT_EVP, 's', "Use specified EVP cipher"},
377 {"decrypt", OPT_DECRYPT, '-',
378 "Time decryption instead of encryption (only EVP)"},
379 {"mr", OPT_MR, '-', "Produce machine readable output"},
381 {"misalign", OPT_MISALIGN, 'n', "Amount to mis-align buffers"},
382 {"elapsed", OPT_ELAPSED, '-',
383 "Measure time in real time instead of CPU user time"},
385 {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"},
387 #ifndef OPENSSL_NO_ASYNC
388 {"async_jobs", OPT_ASYNCJOBS, 'p', "Enable async mode and start pnum jobs"},
390 #ifndef OPENSSL_NO_ENGINE
391 {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
406 #define D_CBC_IDEA 10
407 #define D_CBC_SEED 11
411 #define D_CBC_CAST 15
412 #define D_CBC_128_AES 16
413 #define D_CBC_192_AES 17
414 #define D_CBC_256_AES 18
415 #define D_CBC_128_CML 19
416 #define D_CBC_192_CML 20
417 #define D_CBC_256_CML 21
421 #define D_WHIRLPOOL 25
422 #define D_IGE_128_AES 26
423 #define D_IGE_192_AES 27
424 #define D_IGE_256_AES 28
426 static OPT_PAIR doit_choices[] = {
427 #ifndef OPENSSL_NO_MD2
430 #ifndef OPENSSL_NO_MDC2
433 #ifndef OPENSSL_NO_MD4
436 #ifndef OPENSSL_NO_MD5
439 #ifndef OPENSSL_NO_MD5
443 {"sha256", D_SHA256},
444 {"sha512", D_SHA512},
445 #ifndef OPENSSL_NO_WHIRLPOOL
446 {"whirlpool", D_WHIRLPOOL},
448 #ifndef OPENSSL_NO_RMD160
449 {"ripemd", D_RMD160},
450 {"rmd160", D_RMD160},
451 {"ripemd160", D_RMD160},
453 #ifndef OPENSSL_NO_RC4
456 #ifndef OPENSSL_NO_DES
457 {"des-cbc", D_CBC_DES},
458 {"des-ede3", D_EDE3_DES},
460 {"aes-128-cbc", D_CBC_128_AES},
461 {"aes-192-cbc", D_CBC_192_AES},
462 {"aes-256-cbc", D_CBC_256_AES},
463 {"aes-128-ige", D_IGE_128_AES},
464 {"aes-192-ige", D_IGE_192_AES},
465 {"aes-256-ige", D_IGE_256_AES},
466 #ifndef OPENSSL_NO_RC2
467 {"rc2-cbc", D_CBC_RC2},
470 #ifndef OPENSSL_NO_RC5
471 {"rc5-cbc", D_CBC_RC5},
474 #ifndef OPENSSL_NO_IDEA
475 {"idea-cbc", D_CBC_IDEA},
476 {"idea", D_CBC_IDEA},
478 #ifndef OPENSSL_NO_SEED
479 {"seed-cbc", D_CBC_SEED},
480 {"seed", D_CBC_SEED},
482 #ifndef OPENSSL_NO_BF
483 {"bf-cbc", D_CBC_BF},
484 {"blowfish", D_CBC_BF},
487 #ifndef OPENSSL_NO_CAST
488 {"cast-cbc", D_CBC_CAST},
489 {"cast", D_CBC_CAST},
490 {"cast5", D_CBC_CAST},
496 #ifndef OPENSSL_NO_DSA
498 # define R_DSA_1024 1
499 # define R_DSA_2048 2
500 static OPT_PAIR dsa_choices[] = {
501 {"dsa512", R_DSA_512},
502 {"dsa1024", R_DSA_1024},
503 {"dsa2048", R_DSA_2048},
514 #define R_RSA_15360 6
515 static OPT_PAIR rsa_choices[] = {
516 {"rsa512", R_RSA_512},
517 {"rsa1024", R_RSA_1024},
518 {"rsa2048", R_RSA_2048},
519 {"rsa3072", R_RSA_3072},
520 {"rsa4096", R_RSA_4096},
521 {"rsa7680", R_RSA_7680},
522 {"rsa15360", R_RSA_15360},
542 #define R_EC_X25519 16
543 #ifndef OPENSSL_NO_EC
544 static OPT_PAIR ecdsa_choices[] = {
545 {"ecdsap160", R_EC_P160},
546 {"ecdsap192", R_EC_P192},
547 {"ecdsap224", R_EC_P224},
548 {"ecdsap256", R_EC_P256},
549 {"ecdsap384", R_EC_P384},
550 {"ecdsap521", R_EC_P521},
551 {"ecdsak163", R_EC_K163},
552 {"ecdsak233", R_EC_K233},
553 {"ecdsak283", R_EC_K283},
554 {"ecdsak409", R_EC_K409},
555 {"ecdsak571", R_EC_K571},
556 {"ecdsab163", R_EC_B163},
557 {"ecdsab233", R_EC_B233},
558 {"ecdsab283", R_EC_B283},
559 {"ecdsab409", R_EC_B409},
560 {"ecdsab571", R_EC_B571},
563 static OPT_PAIR ecdh_choices[] = {
564 {"ecdhp160", R_EC_P160},
565 {"ecdhp192", R_EC_P192},
566 {"ecdhp224", R_EC_P224},
567 {"ecdhp256", R_EC_P256},
568 {"ecdhp384", R_EC_P384},
569 {"ecdhp521", R_EC_P521},
570 {"ecdhk163", R_EC_K163},
571 {"ecdhk233", R_EC_K233},
572 {"ecdhk283", R_EC_K283},
573 {"ecdhk409", R_EC_K409},
574 {"ecdhk571", R_EC_K571},
575 {"ecdhb163", R_EC_B163},
576 {"ecdhb233", R_EC_B233},
577 {"ecdhb283", R_EC_B283},
578 {"ecdhb409", R_EC_B409},
579 {"ecdhb571", R_EC_B571},
580 {"ecdhx25519", R_EC_X25519},
586 # define COND(d) (count < (d))
587 # define COUNT(d) (d)
589 # define COND(c) (run && count<0x7fffffff)
590 # define COUNT(d) (count)
594 static char *engine_id = NULL;
597 #ifndef OPENSSL_NO_MD2
598 static int EVP_Digest_MD2_loop(void *args)
600 loopargs_t *tempargs = (loopargs_t *)args;
601 unsigned char *buf = tempargs->buf;
602 unsigned char md2[MD2_DIGEST_LENGTH];
604 for (count = 0; COND(c[D_MD2][testnum]); count++)
605 EVP_Digest(buf, (unsigned long)lengths[testnum], &(md2[0]), NULL,
611 #ifndef OPENSSL_NO_MDC2
612 static int EVP_Digest_MDC2_loop(void *args)
614 loopargs_t *tempargs = (loopargs_t *)args;
615 unsigned char *buf = tempargs->buf;
616 unsigned char mdc2[MDC2_DIGEST_LENGTH];
618 for (count = 0; COND(c[D_MDC2][testnum]); count++)
619 EVP_Digest(buf, (unsigned long)lengths[testnum], &(mdc2[0]), NULL,
625 #ifndef OPENSSL_NO_MD4
626 static int EVP_Digest_MD4_loop(void *args)
628 loopargs_t *tempargs = (loopargs_t *)args;
629 unsigned char *buf = tempargs->buf;
630 unsigned char md4[MD4_DIGEST_LENGTH];
632 for (count = 0; COND(c[D_MD4][testnum]); count++)
633 EVP_Digest(&(buf[0]), (unsigned long)lengths[testnum], &(md4[0]),
634 NULL, EVP_md4(), NULL);
639 #ifndef OPENSSL_NO_MD5
640 static int MD5_loop(void *args)
642 loopargs_t *tempargs = (loopargs_t *)args;
643 unsigned char *buf = tempargs->buf;
644 unsigned char md5[MD5_DIGEST_LENGTH];
646 for (count = 0; COND(c[D_MD5][testnum]); count++)
647 MD5(buf, lengths[testnum], md5);
651 static int HMAC_loop(void *args)
653 loopargs_t *tempargs = (loopargs_t *)args;
654 unsigned char *buf = tempargs->buf;
655 HMAC_CTX *hctx = tempargs->hctx;
656 unsigned char hmac[MD5_DIGEST_LENGTH];
658 for (count = 0; COND(c[D_HMAC][testnum]); count++) {
659 HMAC_Init_ex(hctx, NULL, 0, NULL, NULL);
660 HMAC_Update(hctx, buf, lengths[testnum]);
661 HMAC_Final(hctx, &(hmac[0]), NULL);
667 static int SHA1_loop(void *args)
669 loopargs_t *tempargs = (loopargs_t *)args;
670 unsigned char *buf = tempargs->buf;
671 unsigned char sha[SHA_DIGEST_LENGTH];
673 for (count = 0; COND(c[D_SHA1][testnum]); count++)
674 SHA1(buf, lengths[testnum], sha);
678 static int SHA256_loop(void *args)
680 loopargs_t *tempargs = (loopargs_t *)args;
681 unsigned char *buf = tempargs->buf;
682 unsigned char sha256[SHA256_DIGEST_LENGTH];
684 for (count = 0; COND(c[D_SHA256][testnum]); count++)
685 SHA256(buf, lengths[testnum], sha256);
689 static int SHA512_loop(void *args)
691 loopargs_t *tempargs = (loopargs_t *)args;
692 unsigned char *buf = tempargs->buf;
693 unsigned char sha512[SHA512_DIGEST_LENGTH];
695 for (count = 0; COND(c[D_SHA512][testnum]); count++)
696 SHA512(buf, lengths[testnum], sha512);
700 #ifndef OPENSSL_NO_WHIRLPOOL
701 static int WHIRLPOOL_loop(void *args)
703 loopargs_t *tempargs = (loopargs_t *)args;
704 unsigned char *buf = tempargs->buf;
705 unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];
707 for (count = 0; COND(c[D_WHIRLPOOL][testnum]); count++)
708 WHIRLPOOL(buf, lengths[testnum], whirlpool);
713 #ifndef OPENSSL_NO_RMD160
714 static int EVP_Digest_RMD160_loop(void *args)
716 loopargs_t *tempargs = (loopargs_t *)args;
717 unsigned char *buf = tempargs->buf;
718 unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
720 for (count = 0; COND(c[D_RMD160][testnum]); count++)
721 EVP_Digest(buf, (unsigned long)lengths[testnum], &(rmd160[0]), NULL,
722 EVP_ripemd160(), NULL);
727 #ifndef OPENSSL_NO_RC4
728 static RC4_KEY rc4_ks;
729 static int RC4_loop(void *args)
731 loopargs_t *tempargs = (loopargs_t *)args;
732 unsigned char *buf = tempargs->buf;
734 for (count = 0; COND(c[D_RC4][testnum]); count++)
735 RC4(&rc4_ks, (unsigned int)lengths[testnum], buf, buf);
740 #ifndef OPENSSL_NO_DES
741 static unsigned char DES_iv[8];
742 static DES_key_schedule sch;
743 static DES_key_schedule sch2;
744 static DES_key_schedule sch3;
745 static int DES_ncbc_encrypt_loop(void *args)
747 loopargs_t *tempargs = (loopargs_t *)args;
748 unsigned char *buf = tempargs->buf;
750 for (count = 0; COND(c[D_CBC_DES][testnum]); count++)
751 DES_ncbc_encrypt(buf, buf, lengths[testnum], &sch,
752 &DES_iv, DES_ENCRYPT);
756 static int DES_ede3_cbc_encrypt_loop(void *args)
758 loopargs_t *tempargs = (loopargs_t *)args;
759 unsigned char *buf = tempargs->buf;
761 for (count = 0; COND(c[D_EDE3_DES][testnum]); count++)
762 DES_ede3_cbc_encrypt(buf, buf, lengths[testnum],
764 &DES_iv, DES_ENCRYPT);
769 #define MAX_BLOCK_SIZE 128
771 static unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
772 static AES_KEY aes_ks1, aes_ks2, aes_ks3;
773 static int AES_cbc_128_encrypt_loop(void *args)
775 loopargs_t *tempargs = (loopargs_t *)args;
776 unsigned char *buf = tempargs->buf;
778 for (count = 0; COND(c[D_CBC_128_AES][testnum]); count++)
779 AES_cbc_encrypt(buf, buf,
780 (unsigned long)lengths[testnum], &aes_ks1,
785 static int AES_cbc_192_encrypt_loop(void *args)
787 loopargs_t *tempargs = (loopargs_t *)args;
788 unsigned char *buf = tempargs->buf;
790 for (count = 0; COND(c[D_CBC_192_AES][testnum]); count++)
791 AES_cbc_encrypt(buf, buf,
792 (unsigned long)lengths[testnum], &aes_ks2,
797 static int AES_cbc_256_encrypt_loop(void *args)
799 loopargs_t *tempargs = (loopargs_t *)args;
800 unsigned char *buf = tempargs->buf;
802 for (count = 0; COND(c[D_CBC_256_AES][testnum]); count++)
803 AES_cbc_encrypt(buf, buf,
804 (unsigned long)lengths[testnum], &aes_ks3,
809 static int AES_ige_128_encrypt_loop(void *args)
811 loopargs_t *tempargs = (loopargs_t *)args;
812 unsigned char *buf = tempargs->buf;
813 unsigned char *buf2 = tempargs->buf2;
815 for (count = 0; COND(c[D_IGE_128_AES][testnum]); count++)
816 AES_ige_encrypt(buf, buf2,
817 (unsigned long)lengths[testnum], &aes_ks1,
822 static int AES_ige_192_encrypt_loop(void *args)
824 loopargs_t *tempargs = (loopargs_t *)args;
825 unsigned char *buf = tempargs->buf;
826 unsigned char *buf2 = tempargs->buf2;
828 for (count = 0; COND(c[D_IGE_192_AES][testnum]); count++)
829 AES_ige_encrypt(buf, buf2,
830 (unsigned long)lengths[testnum], &aes_ks2,
835 static int AES_ige_256_encrypt_loop(void *args)
837 loopargs_t *tempargs = (loopargs_t *)args;
838 unsigned char *buf = tempargs->buf;
839 unsigned char *buf2 = tempargs->buf2;
841 for (count = 0; COND(c[D_IGE_256_AES][testnum]); count++)
842 AES_ige_encrypt(buf, buf2,
843 (unsigned long)lengths[testnum], &aes_ks3,
848 static int CRYPTO_gcm128_aad_loop(void *args)
850 loopargs_t *tempargs = (loopargs_t *)args;
851 unsigned char *buf = tempargs->buf;
852 GCM128_CONTEXT *gcm_ctx = tempargs->gcm_ctx;
854 for (count = 0; COND(c[D_GHASH][testnum]); count++)
855 CRYPTO_gcm128_aad(gcm_ctx, buf, lengths[testnum]);
859 static int decrypt = 0;
860 static int EVP_Update_loop(void *args)
862 loopargs_t *tempargs = (loopargs_t *)args;
863 unsigned char *buf = tempargs->buf;
864 EVP_CIPHER_CTX *ctx = tempargs->ctx;
868 COND(save_count * 4 * lengths[0] / lengths[testnum]);
870 EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
873 COND(save_count * 4 * lengths[0] / lengths[testnum]);
875 EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
877 EVP_DecryptFinal_ex(ctx, buf, &outl);
879 EVP_EncryptFinal_ex(ctx, buf, &outl);
883 static const EVP_MD *evp_md = NULL;
884 static int EVP_Digest_loop(void *args)
886 loopargs_t *tempargs = (loopargs_t *)args;
887 unsigned char *buf = tempargs->buf;
888 unsigned char md[EVP_MAX_MD_SIZE];
891 COND(save_count * 4 * lengths[0] / lengths[testnum]); count++)
892 EVP_Digest(buf, lengths[testnum], &(md[0]), NULL, evp_md, NULL);
897 #ifndef OPENSSL_NO_RSA
898 static long rsa_c[RSA_NUM][2];
900 static int RSA_sign_loop(void *args)
902 loopargs_t *tempargs = (loopargs_t *)args;
903 unsigned char *buf = tempargs->buf;
904 unsigned char *buf2 = tempargs->buf2;
905 unsigned int *rsa_num = tempargs->siglen;
906 RSA **rsa_key = tempargs->rsa_key;
908 for (count = 0; COND(rsa_c[testnum][0]); count++) {
909 ret = RSA_sign(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
911 BIO_printf(bio_err, "RSA sign failure\n");
912 ERR_print_errors(bio_err);
920 static int RSA_verify_loop(void *args)
922 loopargs_t *tempargs = (loopargs_t *)args;
923 unsigned char *buf = tempargs->buf;
924 unsigned char *buf2 = tempargs->buf2;
925 unsigned int rsa_num = *(tempargs->siglen);
926 RSA **rsa_key = tempargs->rsa_key;
928 for (count = 0; COND(rsa_c[testnum][1]); count++) {
929 ret = RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
931 BIO_printf(bio_err, "RSA verify failure\n");
932 ERR_print_errors(bio_err);
941 #ifndef OPENSSL_NO_DSA
942 static long dsa_c[DSA_NUM][2];
943 static int DSA_sign_loop(void *args)
945 loopargs_t *tempargs = (loopargs_t *)args;
946 unsigned char *buf = tempargs->buf;
947 unsigned char *buf2 = tempargs->buf2;
948 DSA **dsa_key = tempargs->dsa_key;
949 unsigned int *siglen = tempargs->siglen;
951 for (count = 0; COND(dsa_c[testnum][0]); count++) {
952 ret = DSA_sign(0, buf, 20, buf2, siglen, dsa_key[testnum]);
954 BIO_printf(bio_err, "DSA sign failure\n");
955 ERR_print_errors(bio_err);
963 static int DSA_verify_loop(void *args)
965 loopargs_t *tempargs = (loopargs_t *)args;
966 unsigned char *buf = tempargs->buf;
967 unsigned char *buf2 = tempargs->buf2;
968 DSA **dsa_key = tempargs->dsa_key;
969 unsigned int siglen = *(tempargs->siglen);
971 for (count = 0; COND(dsa_c[testnum][1]); count++) {
972 ret = DSA_verify(0, buf, 20, buf2, siglen, dsa_key[testnum]);
974 BIO_printf(bio_err, "DSA verify failure\n");
975 ERR_print_errors(bio_err);
984 #ifndef OPENSSL_NO_EC
985 static long ecdsa_c[EC_NUM][2];
986 static int ECDSA_sign_loop(void *args)
988 loopargs_t *tempargs = (loopargs_t *)args;
989 unsigned char *buf = tempargs->buf;
990 EC_KEY **ecdsa = tempargs->ecdsa;
991 unsigned char *ecdsasig = tempargs->buf2;
992 unsigned int *ecdsasiglen = tempargs->siglen;
994 for (count = 0; COND(ecdsa_c[testnum][0]); count++) {
995 ret = ECDSA_sign(0, buf, 20,
996 ecdsasig, ecdsasiglen, ecdsa[testnum]);
998 BIO_printf(bio_err, "ECDSA sign failure\n");
999 ERR_print_errors(bio_err);
1007 static int ECDSA_verify_loop(void *args)
1009 loopargs_t *tempargs = (loopargs_t *)args;
1010 unsigned char *buf = tempargs->buf;
1011 EC_KEY **ecdsa = tempargs->ecdsa;
1012 unsigned char *ecdsasig = tempargs->buf2;
1013 unsigned int ecdsasiglen = *(tempargs->siglen);
1015 for (count = 0; COND(ecdsa_c[testnum][1]); count++) {
1016 ret = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen,
1019 BIO_printf(bio_err, "ECDSA verify failure\n");
1020 ERR_print_errors(bio_err);
1029 static void *(*kdf) (const void *in, size_t inlen, void *out,
1032 static int ECDH_compute_key_loop(void *args)
1034 loopargs_t *tempargs = (loopargs_t *)args;
1035 EC_KEY **ecdh_a = tempargs->ecdh_a;
1036 EC_KEY **ecdh_b = tempargs->ecdh_b;
1037 unsigned char *secret_a = tempargs->secret_a;
1039 for (count = 0; COND(ecdh_c[testnum][0]); count++) {
1040 ECDH_compute_key(secret_a, outlen,
1041 EC_KEY_get0_public_key(ecdh_b[testnum]),
1042 ecdh_a[testnum], kdf);
1049 static int run_benchmark(int async_jobs, int (*loop_function)(void *), loopargs_t *loopargs)
1051 int job_op_count = 0;
1052 int total_op_count = 0;
1053 int num_inprogress = 0;
1056 OSSL_ASYNC_FD job_fd = 0;
1057 size_t num_job_fds = 0;
1061 if (async_jobs == 0) {
1062 return loop_function((void *)loopargs);
1066 for (i = 0; i < async_jobs && !error; i++) {
1067 switch (ASYNC_start_job(&(loopargs[i].inprogress_job), loopargs[i].wait_ctx,
1068 &job_op_count, loop_function,
1069 (void *)(loopargs + i), sizeof(loopargs_t))) {
1074 if (job_op_count == -1) {
1077 total_op_count += job_op_count;
1082 BIO_printf(bio_err, "Failure in the job\n");
1083 ERR_print_errors(bio_err);
1089 while (num_inprogress > 0) {
1090 #if defined(OPENSSL_SYS_WINDOWS)
1092 #elif defined(OPENSSL_SYS_UNIX)
1093 int select_result = 0;
1094 OSSL_ASYNC_FD max_fd = 0;
1097 FD_ZERO(&waitfdset);
1099 for (i = 0; i < async_jobs && num_inprogress > 0; i++) {
1100 if (loopargs[i].inprogress_job == NULL)
1103 if (!ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, NULL, &num_job_fds)
1104 || num_job_fds > 1) {
1105 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1106 ERR_print_errors(bio_err);
1110 ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd, &num_job_fds);
1111 FD_SET(job_fd, &waitfdset);
1112 if (job_fd > max_fd)
1116 if (max_fd >= (OSSL_ASYNC_FD)FD_SETSIZE) {
1118 "Error: max_fd (%d) must be smaller than FD_SETSIZE (%d). "
1119 "Decrease the value of async_jobs\n",
1120 max_fd, FD_SETSIZE);
1121 ERR_print_errors(bio_err);
1126 select_result = select(max_fd + 1, &waitfdset, NULL, NULL, NULL);
1127 if (select_result == -1 && errno == EINTR)
1130 if (select_result == -1) {
1131 BIO_printf(bio_err, "Failure in the select\n");
1132 ERR_print_errors(bio_err);
1137 if (select_result == 0)
1141 for (i = 0; i < async_jobs; i++) {
1142 if (loopargs[i].inprogress_job == NULL)
1145 if (!ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, NULL, &num_job_fds)
1146 || num_job_fds > 1) {
1147 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1148 ERR_print_errors(bio_err);
1152 ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd, &num_job_fds);
1154 #if defined(OPENSSL_SYS_UNIX)
1155 if (num_job_fds == 1 && !FD_ISSET(job_fd, &waitfdset))
1157 #elif defined(OPENSSL_SYS_WINDOWS)
1158 if (num_job_fds == 1 &&
1159 !PeekNamedPipe(job_fd, NULL, 0, NULL, &avail, NULL) && avail > 0)
1163 switch (ASYNC_start_job(&(loopargs[i].inprogress_job), loopargs[i].wait_ctx,
1164 &job_op_count, loop_function, (void *)(loopargs + i),
1165 sizeof(loopargs_t))) {
1169 if (job_op_count == -1) {
1172 total_op_count += job_op_count;
1175 loopargs[i].inprogress_job = NULL;
1180 loopargs[i].inprogress_job = NULL;
1181 BIO_printf(bio_err, "Failure in the job\n");
1182 ERR_print_errors(bio_err);
1189 return error ? -1 : total_op_count;
1192 int speed_main(int argc, char **argv)
1194 loopargs_t *loopargs = NULL;
1195 int loopargs_len = 0;
1197 const EVP_CIPHER *evp_cipher = NULL;
1200 int multiblock = 0, doit[ALGOR_NUM], pr_header = 0;
1201 #ifndef OPENSSL_NO_DSA
1202 int dsa_doit[DSA_NUM];
1204 int rsa_doit[RSA_NUM];
1205 int ret = 1, i, k, misalign = 0;
1206 long c[ALGOR_NUM][SIZE_NUM], count = 0, save_count = 0;
1211 /* What follows are the buffers and key material. */
1212 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA)
1215 #ifndef OPENSSL_NO_RC5
1218 #ifndef OPENSSL_NO_RC2
1221 #ifndef OPENSSL_NO_IDEA
1222 IDEA_KEY_SCHEDULE idea_ks;
1224 #ifndef OPENSSL_NO_SEED
1225 SEED_KEY_SCHEDULE seed_ks;
1227 #ifndef OPENSSL_NO_BF
1230 #ifndef OPENSSL_NO_CAST
1233 static const unsigned char key16[16] = {
1234 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1235 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1237 static const unsigned char key24[24] = {
1238 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1239 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1240 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1242 static const unsigned char key32[32] = {
1243 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1244 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1245 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1246 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1248 #ifndef OPENSSL_NO_CAMELLIA
1249 static const unsigned char ckey24[24] = {
1250 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1251 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1252 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1254 static const unsigned char ckey32[32] = {
1255 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1256 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1257 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1258 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1260 CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
1262 #ifndef OPENSSL_NO_DES
1263 static DES_cblock key = {
1264 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
1266 static DES_cblock key2 = {
1267 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1269 static DES_cblock key3 = {
1270 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1273 #ifndef OPENSSL_NO_RSA
1274 static unsigned int rsa_bits[RSA_NUM] = {
1275 512, 1024, 2048, 3072, 4096, 7680, 15360
1277 static unsigned char *rsa_data[RSA_NUM] = {
1278 test512, test1024, test2048, test3072, test4096, test7680, test15360
1280 static int rsa_data_length[RSA_NUM] = {
1281 sizeof(test512), sizeof(test1024),
1282 sizeof(test2048), sizeof(test3072),
1283 sizeof(test4096), sizeof(test7680),
1287 #ifndef OPENSSL_NO_DSA
1288 static unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
1290 #ifndef OPENSSL_NO_EC
1292 * We only test over the following curves as they are representative, To
1293 * add tests over more curves, simply add the curve NID and curve name to
1294 * the following arrays and increase the EC_NUM value accordingly.
1296 static unsigned int test_curves[EC_NUM] = {
1298 NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
1299 NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
1301 NID_sect163k1, NID_sect233k1, NID_sect283k1,
1302 NID_sect409k1, NID_sect571k1, NID_sect163r2,
1303 NID_sect233r1, NID_sect283r1, NID_sect409r1,
1308 static const char *test_curves_names[EC_NUM] = {
1310 "secp160r1", "nistp192", "nistp224",
1311 "nistp256", "nistp384", "nistp521",
1313 "nistk163", "nistk233", "nistk283",
1314 "nistk409", "nistk571", "nistb163",
1315 "nistb233", "nistb283", "nistb409",
1320 static int test_curves_bits[EC_NUM] = {
1326 571, 253 /* X25519 */
1329 #ifndef OPENSSL_NO_EC
1330 int ecdsa_doit[EC_NUM];
1331 int secret_size_a, secret_size_b;
1332 int ecdh_checks = 1;
1334 long ecdh_c[EC_NUM][2];
1335 int ecdh_doit[EC_NUM];
1338 memset(results, 0, sizeof(results));
1340 memset(c, 0, sizeof(c));
1341 #ifndef OPENSSL_NO_DES
1342 memset(DES_iv, 0, sizeof(DES_iv));
1344 memset(iv, 0, sizeof(iv));
1346 for (i = 0; i < ALGOR_NUM; i++)
1348 for (i = 0; i < RSA_NUM; i++)
1350 #ifndef OPENSSL_NO_DSA
1351 for (i = 0; i < DSA_NUM; i++)
1354 #ifndef OPENSSL_NO_EC
1355 for (i = 0; i < EC_NUM; i++)
1357 for (i = 0; i < EC_NUM; i++)
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 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 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 if (!ASYNC_init_thread(async_jobs, async_jobs)) {
1522 BIO_printf(bio_err, "Error creating the ASYNC job pool\n");
1527 loopargs_len = (async_jobs == 0 ? 1 : async_jobs);
1528 loopargs = app_malloc(loopargs_len * sizeof(loopargs_t), "array of loopargs");
1529 memset(loopargs, 0, loopargs_len * sizeof(loopargs_t));
1531 for (i = 0; i < loopargs_len; i++) {
1532 if (async_jobs > 0) {
1533 loopargs[i].wait_ctx = ASYNC_WAIT_CTX_new();
1534 if (loopargs[i].wait_ctx == NULL) {
1535 BIO_printf(bio_err, "Error creating the ASYNC_WAIT_CTX\n");
1540 loopargs[i].buf_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1541 loopargs[i].buf2_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1542 /* Align the start of buffers on a 64 byte boundary */
1543 loopargs[i].buf = loopargs[i].buf_malloc + misalign;
1544 loopargs[i].buf2 = loopargs[i].buf2_malloc + misalign;
1545 loopargs[i].siglen = app_malloc(sizeof(unsigned int), "signature length");
1546 #ifndef OPENSSL_NO_EC
1547 loopargs[i].secret_a = app_malloc(MAX_ECDH_SIZE, "ECDH secret a");
1548 loopargs[i].secret_b = app_malloc(MAX_ECDH_SIZE, "ECDH secret b");
1553 if (multi && do_multi(multi))
1557 /* Initialize the engine after the fork */
1558 (void)setup_engine(engine_id, 0);
1560 /* No parameters; turn on everything. */
1561 if ((argc == 0) && !doit[D_EVP]) {
1562 for (i = 0; i < ALGOR_NUM; i++)
1565 for (i = 0; i < RSA_NUM; i++)
1567 #ifndef OPENSSL_NO_DSA
1568 for (i = 0; i < DSA_NUM; i++)
1571 #ifndef OPENSSL_NO_EC
1572 for (i = 0; i < EC_NUM; i++)
1574 for (i = 0; i < EC_NUM; i++)
1578 for (i = 0; i < ALGOR_NUM; i++)
1582 if (usertime == 0 && !mr)
1584 "You have chosen to measure elapsed time "
1585 "instead of user CPU time.\n");
1587 #ifndef OPENSSL_NO_RSA
1588 for (i = 0; i < loopargs_len; i++) {
1589 for (k = 0; k < RSA_NUM; k++) {
1590 const unsigned char *p;
1593 loopargs[i].rsa_key[k] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[k]);
1594 if (loopargs[i].rsa_key[k] == NULL) {
1595 BIO_printf(bio_err, "internal error loading RSA key number %d\n",
1602 #ifndef OPENSSL_NO_DSA
1603 for (i = 0; i < loopargs_len; i++) {
1604 loopargs[i].dsa_key[0] = get_dsa512();
1605 loopargs[i].dsa_key[1] = get_dsa1024();
1606 loopargs[i].dsa_key[2] = get_dsa2048();
1609 #ifndef OPENSSL_NO_DES
1610 DES_set_key_unchecked(&key, &sch);
1611 DES_set_key_unchecked(&key2, &sch2);
1612 DES_set_key_unchecked(&key3, &sch3);
1614 AES_set_encrypt_key(key16, 128, &aes_ks1);
1615 AES_set_encrypt_key(key24, 192, &aes_ks2);
1616 AES_set_encrypt_key(key32, 256, &aes_ks3);
1617 #ifndef OPENSSL_NO_CAMELLIA
1618 Camellia_set_key(key16, 128, &camellia_ks1);
1619 Camellia_set_key(ckey24, 192, &camellia_ks2);
1620 Camellia_set_key(ckey32, 256, &camellia_ks3);
1622 #ifndef OPENSSL_NO_IDEA
1623 IDEA_set_encrypt_key(key16, &idea_ks);
1625 #ifndef OPENSSL_NO_SEED
1626 SEED_set_key(key16, &seed_ks);
1628 #ifndef OPENSSL_NO_RC4
1629 RC4_set_key(&rc4_ks, 16, key16);
1631 #ifndef OPENSSL_NO_RC2
1632 RC2_set_key(&rc2_ks, 16, key16, 128);
1634 #ifndef OPENSSL_NO_RC5
1635 RC5_32_set_key(&rc5_ks, 16, key16, 12);
1637 #ifndef OPENSSL_NO_BF
1638 BF_set_key(&bf_ks, 16, key16);
1640 #ifndef OPENSSL_NO_CAST
1641 CAST_set_key(&cast_ks, 16, key16);
1643 #ifndef OPENSSL_NO_RSA
1644 memset(rsa_c, 0, sizeof(rsa_c));
1647 # ifndef OPENSSL_NO_DES
1648 BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1654 for (it = count; it; it--)
1655 DES_ecb_encrypt((DES_cblock *)loopargs[0].buf,
1656 (DES_cblock *)loopargs[0].buf, &sch, DES_ENCRYPT);
1660 c[D_MD2][0] = count / 10;
1661 c[D_MDC2][0] = count / 10;
1662 c[D_MD4][0] = count;
1663 c[D_MD5][0] = count;
1664 c[D_HMAC][0] = count;
1665 c[D_SHA1][0] = count;
1666 c[D_RMD160][0] = count;
1667 c[D_RC4][0] = count * 5;
1668 c[D_CBC_DES][0] = count;
1669 c[D_EDE3_DES][0] = count / 3;
1670 c[D_CBC_IDEA][0] = count;
1671 c[D_CBC_SEED][0] = count;
1672 c[D_CBC_RC2][0] = count;
1673 c[D_CBC_RC5][0] = count;
1674 c[D_CBC_BF][0] = count;
1675 c[D_CBC_CAST][0] = count;
1676 c[D_CBC_128_AES][0] = count;
1677 c[D_CBC_192_AES][0] = count;
1678 c[D_CBC_256_AES][0] = count;
1679 c[D_CBC_128_CML][0] = count;
1680 c[D_CBC_192_CML][0] = count;
1681 c[D_CBC_256_CML][0] = count;
1682 c[D_SHA256][0] = count;
1683 c[D_SHA512][0] = count;
1684 c[D_WHIRLPOOL][0] = count;
1685 c[D_IGE_128_AES][0] = count;
1686 c[D_IGE_192_AES][0] = count;
1687 c[D_IGE_256_AES][0] = count;
1688 c[D_GHASH][0] = count;
1690 for (i = 1; i < SIZE_NUM; i++) {
1693 l0 = (long)lengths[0];
1694 l1 = (long)lengths[i];
1696 c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1697 c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1698 c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1699 c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1700 c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1701 c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1702 c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1703 c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1704 c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1705 c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1706 c[D_GHASH][i] = c[D_GHASH][0] * 4 * l0 / l1;
1708 l0 = (long)lengths[i - 1];
1710 c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1711 c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1712 c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1713 c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1714 c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1715 c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1716 c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1717 c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1718 c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1719 c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1720 c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1721 c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1722 c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1723 c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1724 c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1725 c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1726 c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1727 c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1730 # ifndef OPENSSL_NO_RSA
1731 rsa_c[R_RSA_512][0] = count / 2000;
1732 rsa_c[R_RSA_512][1] = count / 400;
1733 for (i = 1; i < RSA_NUM; i++) {
1734 rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1735 rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1736 if ((rsa_doit[i] <= 1) && (rsa_c[i][0] == 0))
1739 if (rsa_c[i][0] == 0) {
1747 # ifndef OPENSSL_NO_DSA
1748 dsa_c[R_DSA_512][0] = count / 1000;
1749 dsa_c[R_DSA_512][1] = count / 1000 / 2;
1750 for (i = 1; i < DSA_NUM; i++) {
1751 dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1752 dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1753 if ((dsa_doit[i] <= 1) && (dsa_c[i][0] == 0))
1756 if (dsa_c[i] == 0) {
1764 # ifndef OPENSSL_NO_EC
1765 ecdsa_c[R_EC_P160][0] = count / 1000;
1766 ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1767 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1768 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1769 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1770 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1773 if (ecdsa_c[i] == 0) {
1779 ecdsa_c[R_EC_K163][0] = count / 1000;
1780 ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1781 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1782 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1783 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1784 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1787 if (ecdsa_c[i] == 0) {
1793 ecdsa_c[R_EC_B163][0] = count / 1000;
1794 ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1795 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1796 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1797 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1798 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1801 if (ecdsa_c[i] == 0) {
1808 ecdh_c[R_EC_P160][0] = count / 1000;
1809 ecdh_c[R_EC_P160][1] = count / 1000;
1810 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1811 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1812 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1813 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1816 if (ecdh_c[i] == 0) {
1822 ecdh_c[R_EC_K163][0] = count / 1000;
1823 ecdh_c[R_EC_K163][1] = count / 1000;
1824 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1825 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1826 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1827 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1830 if (ecdh_c[i] == 0) {
1836 ecdh_c[R_EC_B163][0] = count / 1000;
1837 ecdh_c[R_EC_B163][1] = count / 1000;
1838 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1839 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1840 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1841 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1844 if (ecdh_c[i] == 0) {
1853 /* not worth fixing */
1854 # error "You cannot disable DES on systems without SIGALRM."
1855 # endif /* OPENSSL_NO_DES */
1858 signal(SIGALRM, sig_done);
1860 #endif /* SIGALRM */
1862 #ifndef OPENSSL_NO_MD2
1864 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1865 print_message(names[D_MD2], c[D_MD2][testnum], lengths[testnum]);
1867 count = run_benchmark(async_jobs, EVP_Digest_MD2_loop, loopargs);
1869 print_result(D_MD2, testnum, count, d);
1873 #ifndef OPENSSL_NO_MDC2
1875 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1876 print_message(names[D_MDC2], c[D_MDC2][testnum], lengths[testnum]);
1878 count = run_benchmark(async_jobs, EVP_Digest_MDC2_loop, loopargs);
1880 print_result(D_MDC2, testnum, count, d);
1885 #ifndef OPENSSL_NO_MD4
1887 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1888 print_message(names[D_MD4], c[D_MD4][testnum], lengths[testnum]);
1890 count = run_benchmark(async_jobs, EVP_Digest_MD4_loop, loopargs);
1892 print_result(D_MD4, testnum, count, d);
1897 #ifndef OPENSSL_NO_MD5
1899 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1900 print_message(names[D_MD5], c[D_MD5][testnum], lengths[testnum]);
1902 count = run_benchmark(async_jobs, MD5_loop, loopargs);
1904 print_result(D_MD5, testnum, count, d);
1909 #ifndef OPENSSL_NO_MD5
1911 for (i = 0; i < loopargs_len; i++) {
1912 loopargs[i].hctx = HMAC_CTX_new();
1913 if (loopargs[i].hctx == NULL) {
1914 BIO_printf(bio_err, "HMAC malloc failure, exiting...");
1918 HMAC_Init_ex(loopargs[i].hctx, (unsigned char *)"This is a key...",
1919 16, EVP_md5(), NULL);
1921 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1922 print_message(names[D_HMAC], c[D_HMAC][testnum], lengths[testnum]);
1924 count = run_benchmark(async_jobs, HMAC_loop, loopargs);
1926 print_result(D_HMAC, testnum, count, d);
1928 for (i = 0; i < loopargs_len; i++) {
1929 HMAC_CTX_free(loopargs[i].hctx);
1934 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1935 print_message(names[D_SHA1], c[D_SHA1][testnum], lengths[testnum]);
1937 count = run_benchmark(async_jobs, SHA1_loop, loopargs);
1939 print_result(D_SHA1, testnum, count, d);
1942 if (doit[D_SHA256]) {
1943 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1944 print_message(names[D_SHA256], c[D_SHA256][testnum], lengths[testnum]);
1946 count = run_benchmark(async_jobs, SHA256_loop, loopargs);
1948 print_result(D_SHA256, testnum, count, d);
1951 if (doit[D_SHA512]) {
1952 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1953 print_message(names[D_SHA512], c[D_SHA512][testnum], lengths[testnum]);
1955 count = run_benchmark(async_jobs, SHA512_loop, loopargs);
1957 print_result(D_SHA512, testnum, count, d);
1961 #ifndef OPENSSL_NO_WHIRLPOOL
1962 if (doit[D_WHIRLPOOL]) {
1963 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1964 print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][testnum], lengths[testnum]);
1966 count = run_benchmark(async_jobs, WHIRLPOOL_loop, loopargs);
1968 print_result(D_WHIRLPOOL, testnum, count, d);
1973 #ifndef OPENSSL_NO_RMD160
1974 if (doit[D_RMD160]) {
1975 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1976 print_message(names[D_RMD160], c[D_RMD160][testnum], lengths[testnum]);
1978 count = run_benchmark(async_jobs, EVP_Digest_RMD160_loop, loopargs);
1980 print_result(D_RMD160, testnum, count, d);
1984 #ifndef OPENSSL_NO_RC4
1986 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1987 print_message(names[D_RC4], c[D_RC4][testnum], lengths[testnum]);
1989 count = run_benchmark(async_jobs, RC4_loop, loopargs);
1991 print_result(D_RC4, testnum, count, d);
1995 #ifndef OPENSSL_NO_DES
1996 if (doit[D_CBC_DES]) {
1997 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1998 print_message(names[D_CBC_DES], c[D_CBC_DES][testnum], lengths[testnum]);
2000 count = run_benchmark(async_jobs, DES_ncbc_encrypt_loop, loopargs);
2002 print_result(D_CBC_DES, testnum, count, d);
2006 if (doit[D_EDE3_DES]) {
2007 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2008 print_message(names[D_EDE3_DES], c[D_EDE3_DES][testnum], lengths[testnum]);
2010 count = run_benchmark(async_jobs, DES_ede3_cbc_encrypt_loop, loopargs);
2012 print_result(D_EDE3_DES, testnum, count, d);
2017 if (doit[D_CBC_128_AES]) {
2018 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2019 print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][testnum],
2022 count = run_benchmark(async_jobs, AES_cbc_128_encrypt_loop, loopargs);
2024 print_result(D_CBC_128_AES, testnum, count, d);
2027 if (doit[D_CBC_192_AES]) {
2028 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2029 print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][testnum],
2032 count = run_benchmark(async_jobs, AES_cbc_192_encrypt_loop, loopargs);
2034 print_result(D_CBC_192_AES, testnum, count, d);
2037 if (doit[D_CBC_256_AES]) {
2038 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2039 print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][testnum],
2042 count = run_benchmark(async_jobs, AES_cbc_256_encrypt_loop, loopargs);
2044 print_result(D_CBC_256_AES, testnum, count, d);
2048 if (doit[D_IGE_128_AES]) {
2049 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2050 print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][testnum],
2053 count = run_benchmark(async_jobs, AES_ige_128_encrypt_loop, loopargs);
2055 print_result(D_IGE_128_AES, testnum, count, d);
2058 if (doit[D_IGE_192_AES]) {
2059 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2060 print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][testnum],
2063 count = run_benchmark(async_jobs, AES_ige_192_encrypt_loop, loopargs);
2065 print_result(D_IGE_192_AES, testnum, count, d);
2068 if (doit[D_IGE_256_AES]) {
2069 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2070 print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][testnum],
2073 count = run_benchmark(async_jobs, AES_ige_256_encrypt_loop, loopargs);
2075 print_result(D_IGE_256_AES, testnum, count, d);
2078 if (doit[D_GHASH]) {
2079 for (i = 0; i < loopargs_len; i++) {
2080 loopargs[i].gcm_ctx = CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
2081 CRYPTO_gcm128_setiv(loopargs[i].gcm_ctx, (unsigned char *)"0123456789ab", 12);
2084 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2085 print_message(names[D_GHASH], c[D_GHASH][testnum], lengths[testnum]);
2087 count = run_benchmark(async_jobs, CRYPTO_gcm128_aad_loop, loopargs);
2089 print_result(D_GHASH, testnum, count, d);
2091 for (i = 0; i < loopargs_len; i++)
2092 CRYPTO_gcm128_release(loopargs[i].gcm_ctx);
2095 #ifndef OPENSSL_NO_CAMELLIA
2096 if (doit[D_CBC_128_CML]) {
2097 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2098 print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][testnum],
2100 if (async_jobs > 0) {
2101 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2105 for (count = 0, run = 1; COND(c[D_CBC_128_CML][testnum]); count++)
2106 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2107 (unsigned long)lengths[testnum], &camellia_ks1,
2108 iv, CAMELLIA_ENCRYPT);
2110 print_result(D_CBC_128_CML, testnum, count, d);
2113 if (doit[D_CBC_192_CML]) {
2114 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2115 print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][testnum],
2117 if (async_jobs > 0) {
2118 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2122 for (count = 0, run = 1; COND(c[D_CBC_192_CML][testnum]); count++)
2123 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2124 (unsigned long)lengths[testnum], &camellia_ks2,
2125 iv, CAMELLIA_ENCRYPT);
2127 print_result(D_CBC_192_CML, testnum, count, d);
2130 if (doit[D_CBC_256_CML]) {
2131 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2132 print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][testnum],
2134 if (async_jobs > 0) {
2135 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2139 for (count = 0, run = 1; COND(c[D_CBC_256_CML][testnum]); count++)
2140 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2141 (unsigned long)lengths[testnum], &camellia_ks3,
2142 iv, CAMELLIA_ENCRYPT);
2144 print_result(D_CBC_256_CML, testnum, count, d);
2148 #ifndef OPENSSL_NO_IDEA
2149 if (doit[D_CBC_IDEA]) {
2150 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2151 print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][testnum], lengths[testnum]);
2152 if (async_jobs > 0) {
2153 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2157 for (count = 0, run = 1; COND(c[D_CBC_IDEA][testnum]); count++)
2158 IDEA_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2159 (unsigned long)lengths[testnum], &idea_ks,
2162 print_result(D_CBC_IDEA, testnum, count, d);
2166 #ifndef OPENSSL_NO_SEED
2167 if (doit[D_CBC_SEED]) {
2168 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2169 print_message(names[D_CBC_SEED], c[D_CBC_SEED][testnum], lengths[testnum]);
2170 if (async_jobs > 0) {
2171 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2175 for (count = 0, run = 1; COND(c[D_CBC_SEED][testnum]); count++)
2176 SEED_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2177 (unsigned long)lengths[testnum], &seed_ks, iv, 1);
2179 print_result(D_CBC_SEED, testnum, count, d);
2183 #ifndef OPENSSL_NO_RC2
2184 if (doit[D_CBC_RC2]) {
2185 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2186 print_message(names[D_CBC_RC2], c[D_CBC_RC2][testnum], lengths[testnum]);
2187 if (async_jobs > 0) {
2188 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2192 for (count = 0, run = 1; COND(c[D_CBC_RC2][testnum]); count++)
2193 RC2_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2194 (unsigned long)lengths[testnum], &rc2_ks,
2197 print_result(D_CBC_RC2, testnum, count, d);
2201 #ifndef OPENSSL_NO_RC5
2202 if (doit[D_CBC_RC5]) {
2203 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2204 print_message(names[D_CBC_RC5], c[D_CBC_RC5][testnum], lengths[testnum]);
2205 if (async_jobs > 0) {
2206 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2210 for (count = 0, run = 1; COND(c[D_CBC_RC5][testnum]); count++)
2211 RC5_32_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2212 (unsigned long)lengths[testnum], &rc5_ks,
2215 print_result(D_CBC_RC5, testnum, count, d);
2219 #ifndef OPENSSL_NO_BF
2220 if (doit[D_CBC_BF]) {
2221 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2222 print_message(names[D_CBC_BF], c[D_CBC_BF][testnum], lengths[testnum]);
2223 if (async_jobs > 0) {
2224 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2228 for (count = 0, run = 1; COND(c[D_CBC_BF][testnum]); count++)
2229 BF_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2230 (unsigned long)lengths[testnum], &bf_ks,
2233 print_result(D_CBC_BF, testnum, count, d);
2237 #ifndef OPENSSL_NO_CAST
2238 if (doit[D_CBC_CAST]) {
2239 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2240 print_message(names[D_CBC_CAST], c[D_CBC_CAST][testnum], lengths[testnum]);
2241 if (async_jobs > 0) {
2242 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2246 for (count = 0, run = 1; COND(c[D_CBC_CAST][testnum]); count++)
2247 CAST_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2248 (unsigned long)lengths[testnum], &cast_ks,
2251 print_result(D_CBC_CAST, testnum, count, d);
2257 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
2258 if (multiblock && evp_cipher) {
2260 (EVP_CIPHER_flags(evp_cipher) &
2261 EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
2262 BIO_printf(bio_err, "%s is not multi-block capable\n",
2263 OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
2266 if (async_jobs > 0) {
2267 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2270 multiblock_speed(evp_cipher);
2275 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2278 names[D_EVP] = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
2280 * -O3 -fschedule-insns messes up an optimization here!
2281 * names[D_EVP] somehow becomes NULL
2283 print_message(names[D_EVP], save_count, lengths[testnum]);
2285 for (k = 0; k < loopargs_len; k++) {
2286 loopargs[k].ctx = EVP_CIPHER_CTX_new();
2288 EVP_DecryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2290 EVP_EncryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2291 EVP_CIPHER_CTX_set_padding(loopargs[k].ctx, 0);
2295 count = run_benchmark(async_jobs, EVP_Update_loop, loopargs);
2297 for (k = 0; k < loopargs_len; k++) {
2298 EVP_CIPHER_CTX_free(loopargs[k].ctx);
2302 names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
2303 print_message(names[D_EVP], save_count, lengths[testnum]);
2305 count = run_benchmark(async_jobs, EVP_Digest_loop, loopargs);
2308 print_result(D_EVP, testnum, count, d);
2312 for (i = 0; i < loopargs_len; i++)
2313 RAND_bytes(loopargs[i].buf, 36);
2315 #ifndef OPENSSL_NO_RSA
2316 for (testnum = 0; testnum < RSA_NUM; testnum++) {
2318 if (!rsa_doit[testnum])
2320 for (i = 0; i < loopargs_len; i++) {
2321 st = RSA_sign(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2322 loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2328 "RSA sign failure. No RSA sign will be done.\n");
2329 ERR_print_errors(bio_err);
2332 pkey_print_message("private", "rsa",
2333 rsa_c[testnum][0], rsa_bits[testnum], RSA_SECONDS);
2334 /* RSA_blinding_on(rsa_key[testnum],NULL); */
2336 count = run_benchmark(async_jobs, RSA_sign_loop, loopargs);
2339 mr ? "+R1:%ld:%d:%.2f\n"
2340 : "%ld %d bit private RSA's in %.2fs\n",
2341 count, rsa_bits[testnum], d);
2342 rsa_results[testnum][0] = d / (double)count;
2346 for (i = 0; i < loopargs_len; i++) {
2347 st = RSA_verify(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2348 *(loopargs[i].siglen), loopargs[i].rsa_key[testnum]);
2354 "RSA verify failure. No RSA verify will be done.\n");
2355 ERR_print_errors(bio_err);
2356 rsa_doit[testnum] = 0;
2358 pkey_print_message("public", "rsa",
2359 rsa_c[testnum][1], rsa_bits[testnum], RSA_SECONDS);
2361 count = run_benchmark(async_jobs, RSA_verify_loop, loopargs);
2364 mr ? "+R2:%ld:%d:%.2f\n"
2365 : "%ld %d bit public RSA's in %.2fs\n",
2366 count, rsa_bits[testnum], d);
2367 rsa_results[testnum][1] = d / (double)count;
2370 if (rsa_count <= 1) {
2371 /* if longer than 10s, don't do any more */
2372 for (testnum++; testnum < RSA_NUM; testnum++)
2373 rsa_doit[testnum] = 0;
2378 for (i = 0; i < loopargs_len; i++)
2379 RAND_bytes(loopargs[i].buf, 36);
2381 #ifndef OPENSSL_NO_DSA
2382 if (RAND_status() != 1) {
2383 RAND_seed(rnd_seed, sizeof rnd_seed);
2385 for (testnum = 0; testnum < DSA_NUM; testnum++) {
2387 if (!dsa_doit[testnum])
2390 /* DSA_generate_key(dsa_key[testnum]); */
2391 /* DSA_sign_setup(dsa_key[testnum],NULL); */
2392 for (i = 0; i < loopargs_len; i++) {
2393 st = DSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2394 loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2400 "DSA sign failure. No DSA sign will be done.\n");
2401 ERR_print_errors(bio_err);
2404 pkey_print_message("sign", "dsa",
2405 dsa_c[testnum][0], dsa_bits[testnum], DSA_SECONDS);
2407 count = run_benchmark(async_jobs, DSA_sign_loop, loopargs);
2410 mr ? "+R3:%ld:%d:%.2f\n"
2411 : "%ld %d bit DSA signs in %.2fs\n",
2412 count, dsa_bits[testnum], d);
2413 dsa_results[testnum][0] = d / (double)count;
2417 for (i = 0; i < loopargs_len; i++) {
2418 st = DSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2419 *(loopargs[i].siglen), loopargs[i].dsa_key[testnum]);
2425 "DSA verify failure. No DSA verify will be done.\n");
2426 ERR_print_errors(bio_err);
2427 dsa_doit[testnum] = 0;
2429 pkey_print_message("verify", "dsa",
2430 dsa_c[testnum][1], dsa_bits[testnum], DSA_SECONDS);
2432 count = run_benchmark(async_jobs, DSA_verify_loop, loopargs);
2435 mr ? "+R4:%ld:%d:%.2f\n"
2436 : "%ld %d bit DSA verify in %.2fs\n",
2437 count, dsa_bits[testnum], d);
2438 dsa_results[testnum][1] = d / (double)count;
2441 if (rsa_count <= 1) {
2442 /* if longer than 10s, don't do any more */
2443 for (testnum++; testnum < DSA_NUM; testnum++)
2444 dsa_doit[testnum] = 0;
2449 #ifndef OPENSSL_NO_EC
2450 if (RAND_status() != 1) {
2451 RAND_seed(rnd_seed, sizeof rnd_seed);
2453 for (testnum = 0; testnum < EC_NUM; testnum++) {
2456 if (!ecdsa_doit[testnum])
2457 continue; /* Ignore Curve */
2458 for (i = 0; i < loopargs_len; i++) {
2459 loopargs[i].ecdsa[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2460 if (loopargs[i].ecdsa[testnum] == NULL) {
2466 BIO_printf(bio_err, "ECDSA failure.\n");
2467 ERR_print_errors(bio_err);
2470 for (i = 0; i < loopargs_len; i++) {
2471 EC_KEY_precompute_mult(loopargs[i].ecdsa[testnum], NULL);
2472 /* Perform ECDSA signature test */
2473 EC_KEY_generate_key(loopargs[i].ecdsa[testnum]);
2474 st = ECDSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2475 loopargs[i].siglen, loopargs[i].ecdsa[testnum]);
2481 "ECDSA sign failure. No ECDSA sign will be done.\n");
2482 ERR_print_errors(bio_err);
2485 pkey_print_message("sign", "ecdsa",
2486 ecdsa_c[testnum][0],
2487 test_curves_bits[testnum], ECDSA_SECONDS);
2489 count = run_benchmark(async_jobs, ECDSA_sign_loop, loopargs);
2493 mr ? "+R5:%ld:%d:%.2f\n" :
2494 "%ld %d bit ECDSA signs in %.2fs \n",
2495 count, test_curves_bits[testnum], d);
2496 ecdsa_results[testnum][0] = d / (double)count;
2500 /* Perform ECDSA verification test */
2501 for (i = 0; i < loopargs_len; i++) {
2502 st = ECDSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2503 *(loopargs[i].siglen), loopargs[i].ecdsa[testnum]);
2509 "ECDSA verify failure. No ECDSA verify will be done.\n");
2510 ERR_print_errors(bio_err);
2511 ecdsa_doit[testnum] = 0;
2513 pkey_print_message("verify", "ecdsa",
2514 ecdsa_c[testnum][1],
2515 test_curves_bits[testnum], ECDSA_SECONDS);
2517 count = run_benchmark(async_jobs, ECDSA_verify_loop, loopargs);
2520 mr ? "+R6:%ld:%d:%.2f\n"
2521 : "%ld %d bit ECDSA verify in %.2fs\n",
2522 count, test_curves_bits[testnum], d);
2523 ecdsa_results[testnum][1] = d / (double)count;
2526 if (rsa_count <= 1) {
2527 /* if longer than 10s, don't do any more */
2528 for (testnum++; testnum < EC_NUM; testnum++)
2529 ecdsa_doit[testnum] = 0;
2535 #ifndef OPENSSL_NO_EC
2536 if (RAND_status() != 1) {
2537 RAND_seed(rnd_seed, sizeof rnd_seed);
2539 for (testnum = 0; testnum < EC_NUM; testnum++) {
2540 if (!ecdh_doit[testnum])
2542 for (i = 0; i < loopargs_len; i++) {
2543 loopargs[i].ecdh_a[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2544 loopargs[i].ecdh_b[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2545 if (loopargs[i].ecdh_a[testnum] == NULL ||
2546 loopargs[i].ecdh_b[testnum] == NULL) {
2551 if (ecdh_checks == 0) {
2552 BIO_printf(bio_err, "ECDH failure.\n");
2553 ERR_print_errors(bio_err);
2556 for (i = 0; i < loopargs_len; i++) {
2557 /* generate two ECDH key pairs */
2558 if (!EC_KEY_generate_key(loopargs[i].ecdh_a[testnum]) ||
2559 !EC_KEY_generate_key(loopargs[i].ecdh_b[testnum])) {
2560 BIO_printf(bio_err, "ECDH key generation failure.\n");
2561 ERR_print_errors(bio_err);
2566 * If field size is not more than 24 octets, then use SHA-1
2567 * hash of result; otherwise, use result (see section 4.8 of
2568 * draft-ietf-tls-ecc-03.txt).
2572 EC_GROUP_get_degree(EC_KEY_get0_group(loopargs[i].ecdh_a[testnum]));
2573 if (field_size <= 24 * 8) {
2574 outlen = KDF1_SHA1_len;
2577 outlen = (field_size + 7) / 8;
2581 ECDH_compute_key(loopargs[i].secret_a, outlen,
2582 EC_KEY_get0_public_key(loopargs[i].ecdh_b[testnum]),
2583 loopargs[i].ecdh_a[testnum], kdf);
2585 ECDH_compute_key(loopargs[i].secret_b, outlen,
2586 EC_KEY_get0_public_key(loopargs[i].ecdh_a[testnum]),
2587 loopargs[i].ecdh_b[testnum], kdf);
2588 if (secret_size_a != secret_size_b)
2593 for (secret_idx = 0; (secret_idx < secret_size_a)
2594 && (ecdh_checks == 1); secret_idx++) {
2595 if (loopargs[i].secret_a[secret_idx] != loopargs[i].secret_b[secret_idx])
2599 if (ecdh_checks == 0) {
2600 BIO_printf(bio_err, "ECDH computations don't match.\n");
2601 ERR_print_errors(bio_err);
2607 if (ecdh_checks != 0) {
2608 pkey_print_message("", "ecdh",
2610 test_curves_bits[testnum], ECDH_SECONDS);
2612 count = run_benchmark(async_jobs, ECDH_compute_key_loop, loopargs);
2615 mr ? "+R7:%ld:%d:%.2f\n" :
2616 "%ld %d-bit ECDH ops in %.2fs\n", count,
2617 test_curves_bits[testnum], d);
2618 ecdh_results[testnum][0] = d / (double)count;
2623 if (rsa_count <= 1) {
2624 /* if longer than 10s, don't do any more */
2625 for (testnum++; testnum < EC_NUM; testnum++)
2626 ecdh_doit[testnum] = 0;
2634 printf("%s\n", OpenSSL_version(OPENSSL_VERSION));
2635 printf("%s\n", OpenSSL_version(OPENSSL_BUILT_ON));
2637 printf("%s ", BN_options());
2638 #ifndef OPENSSL_NO_MD2
2639 printf("%s ", MD2_options());
2641 #ifndef OPENSSL_NO_RC4
2642 printf("%s ", RC4_options());
2644 #ifndef OPENSSL_NO_DES
2645 printf("%s ", DES_options());
2647 printf("%s ", AES_options());
2648 #ifndef OPENSSL_NO_IDEA
2649 printf("%s ", IDEA_options());
2651 #ifndef OPENSSL_NO_BF
2652 printf("%s ", BF_options());
2654 printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
2662 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2665 for (testnum = 0; testnum < SIZE_NUM; testnum++)
2666 printf(mr ? ":%d" : "%7d bytes", lengths[testnum]);
2670 for (k = 0; k < ALGOR_NUM; k++) {
2674 printf("+F:%d:%s", k, names[k]);
2676 printf("%-13s", names[k]);
2677 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2678 if (results[k][testnum] > 10000 && !mr)
2679 printf(" %11.2fk", results[k][testnum] / 1e3);
2681 printf(mr ? ":%.2f" : " %11.2f ", results[k][testnum]);
2685 #ifndef OPENSSL_NO_RSA
2687 for (k = 0; k < RSA_NUM; k++) {
2690 if (testnum && !mr) {
2691 printf("%18ssign verify sign/s verify/s\n", " ");
2695 printf("+F2:%u:%u:%f:%f\n",
2696 k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2698 printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2699 rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2700 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2703 #ifndef OPENSSL_NO_DSA
2705 for (k = 0; k < DSA_NUM; k++) {
2708 if (testnum && !mr) {
2709 printf("%18ssign verify sign/s verify/s\n", " ");
2713 printf("+F3:%u:%u:%f:%f\n",
2714 k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2716 printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2717 dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2718 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2721 #ifndef OPENSSL_NO_EC
2723 for (k = 0; k < EC_NUM; k++) {
2726 if (testnum && !mr) {
2727 printf("%30ssign verify sign/s verify/s\n", " ");
2732 printf("+F4:%u:%u:%f:%f\n",
2733 k, test_curves_bits[k],
2734 ecdsa_results[k][0], ecdsa_results[k][1]);
2736 printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2737 test_curves_bits[k],
2738 test_curves_names[k],
2739 ecdsa_results[k][0], ecdsa_results[k][1],
2740 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2744 #ifndef OPENSSL_NO_EC
2746 for (k = 0; k < EC_NUM; k++) {
2749 if (testnum && !mr) {
2750 printf("%30sop op/s\n", " ");
2754 printf("+F5:%u:%u:%f:%f\n",
2755 k, test_curves_bits[k],
2756 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2759 printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2760 test_curves_bits[k],
2761 test_curves_names[k],
2762 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2769 ERR_print_errors(bio_err);
2770 for (i = 0; i < loopargs_len; i++) {
2771 OPENSSL_free(loopargs[i].buf_malloc);
2772 OPENSSL_free(loopargs[i].buf2_malloc);
2773 OPENSSL_free(loopargs[i].siglen);
2775 #ifndef OPENSSL_NO_RSA
2776 for (i = 0; i < loopargs_len; i++) {
2777 for (k = 0; k < RSA_NUM; k++)
2778 RSA_free(loopargs[i].rsa_key[k]);
2781 #ifndef OPENSSL_NO_DSA
2782 for (i = 0; i < loopargs_len; i++) {
2783 for (k = 0; k < DSA_NUM; k++)
2784 DSA_free(loopargs[i].dsa_key[k]);
2788 #ifndef OPENSSL_NO_EC
2789 for (i = 0; i < loopargs_len; i++) {
2790 for (k = 0; k < EC_NUM; k++) {
2791 EC_KEY_free(loopargs[i].ecdsa[k]);
2792 EC_KEY_free(loopargs[i].ecdh_a[k]);
2793 EC_KEY_free(loopargs[i].ecdh_b[k]);
2795 OPENSSL_free(loopargs[i].secret_a);
2796 OPENSSL_free(loopargs[i].secret_b);
2799 if (async_jobs > 0) {
2800 for (i = 0; i < loopargs_len; i++)
2801 ASYNC_WAIT_CTX_free(loopargs[i].wait_ctx);
2803 ASYNC_cleanup_thread();
2805 OPENSSL_free(loopargs);
2809 static void print_message(const char *s, long num, int length)
2813 mr ? "+DT:%s:%d:%d\n"
2814 : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2815 (void)BIO_flush(bio_err);
2819 mr ? "+DN:%s:%ld:%d\n"
2820 : "Doing %s %ld times on %d size blocks: ", s, num, length);
2821 (void)BIO_flush(bio_err);
2825 static void pkey_print_message(const char *str, const char *str2, long num,
2830 mr ? "+DTP:%d:%s:%s:%d\n"
2831 : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2832 (void)BIO_flush(bio_err);
2836 mr ? "+DNP:%ld:%d:%s:%s\n"
2837 : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2838 (void)BIO_flush(bio_err);
2842 static void print_result(int alg, int run_no, int count, double time_used)
2845 mr ? "+R:%d:%s:%f\n"
2846 : "%d %s's in %.2fs\n", count, names[alg], time_used);
2847 results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2851 static char *sstrsep(char **string, const char *delim)
2854 char *token = *string;
2859 memset(isdelim, 0, sizeof isdelim);
2863 isdelim[(unsigned char)(*delim)] = 1;
2867 while (!isdelim[(unsigned char)(**string)]) {
2879 static int do_multi(int multi)
2884 static char sep[] = ":";
2886 fds = malloc(sizeof(*fds) * multi);
2887 for (n = 0; n < multi; ++n) {
2888 if (pipe(fd) == -1) {
2889 BIO_printf(bio_err, "pipe failure\n");
2893 (void)BIO_flush(bio_err);
2900 if (dup(fd[1]) == -1) {
2901 BIO_printf(bio_err, "dup failed\n");
2910 printf("Forked child %d\n", n);
2913 /* for now, assume the pipe is long enough to take all the output */
2914 for (n = 0; n < multi; ++n) {
2919 f = fdopen(fds[n], "r");
2920 while (fgets(buf, sizeof buf, f)) {
2921 p = strchr(buf, '\n');
2924 if (buf[0] != '+') {
2925 BIO_printf(bio_err, "Don't understand line '%s' from child %d\n",
2929 printf("Got: %s from %d\n", buf, n);
2930 if (strncmp(buf, "+F:", 3) == 0) {
2935 alg = atoi(sstrsep(&p, sep));
2937 for (j = 0; j < SIZE_NUM; ++j)
2938 results[alg][j] += atof(sstrsep(&p, sep));
2939 } else if (strncmp(buf, "+F2:", 4) == 0) {
2944 k = atoi(sstrsep(&p, sep));
2947 d = atof(sstrsep(&p, sep));
2949 rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
2951 rsa_results[k][0] = d;
2953 d = atof(sstrsep(&p, sep));
2955 rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
2957 rsa_results[k][1] = d;
2959 # ifndef OPENSSL_NO_DSA
2960 else if (strncmp(buf, "+F3:", 4) == 0) {
2965 k = atoi(sstrsep(&p, sep));
2968 d = atof(sstrsep(&p, sep));
2970 dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
2972 dsa_results[k][0] = d;
2974 d = atof(sstrsep(&p, sep));
2976 dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
2978 dsa_results[k][1] = d;
2981 # ifndef OPENSSL_NO_EC
2982 else if (strncmp(buf, "+F4:", 4) == 0) {
2987 k = atoi(sstrsep(&p, sep));
2990 d = atof(sstrsep(&p, sep));
2992 ecdsa_results[k][0] =
2993 1 / (1 / ecdsa_results[k][0] + 1 / d);
2995 ecdsa_results[k][0] = d;
2997 d = atof(sstrsep(&p, sep));
2999 ecdsa_results[k][1] =
3000 1 / (1 / ecdsa_results[k][1] + 1 / d);
3002 ecdsa_results[k][1] = d;
3006 # ifndef OPENSSL_NO_EC
3007 else if (strncmp(buf, "+F5:", 4) == 0) {
3012 k = atoi(sstrsep(&p, sep));
3015 d = atof(sstrsep(&p, sep));
3017 ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
3019 ecdh_results[k][0] = d;
3024 else if (strncmp(buf, "+H:", 3) == 0) {
3027 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf, n);
3037 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
3039 static int mblengths[] =
3040 { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
3041 int j, count, num = OSSL_NELEM(mblengths);
3042 const char *alg_name;
3043 unsigned char *inp, *out, no_key[32], no_iv[16];
3044 EVP_CIPHER_CTX *ctx;
3047 inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
3048 out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
3049 ctx = EVP_CIPHER_CTX_new();
3050 EVP_EncryptInit_ex(ctx, evp_cipher, NULL, no_key, no_iv);
3051 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key),
3053 alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
3055 for (j = 0; j < num; j++) {
3056 print_message(alg_name, 0, mblengths[j]);
3058 for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
3059 unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
3060 EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
3061 size_t len = mblengths[j];
3064 memset(aad, 0, 8); /* avoid uninitialized values */
3065 aad[8] = 23; /* SSL3_RT_APPLICATION_DATA */
3066 aad[9] = 3; /* version */
3068 aad[11] = 0; /* length */
3070 mb_param.out = NULL;
3073 mb_param.interleave = 8;
3075 packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
3076 sizeof(mb_param), &mb_param);
3082 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
3083 sizeof(mb_param), &mb_param);
3087 RAND_bytes(out, 16);
3091 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
3092 EVP_AEAD_TLS1_AAD_LEN, aad);
3093 EVP_Cipher(ctx, out, inp, len + pad);
3097 BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
3098 : "%d %s's in %.2fs\n", count, "evp", d);
3099 results[D_EVP][j] = ((double)count) / d * mblengths[j];
3103 fprintf(stdout, "+H");
3104 for (j = 0; j < num; j++)
3105 fprintf(stdout, ":%d", mblengths[j]);
3106 fprintf(stdout, "\n");
3107 fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
3108 for (j = 0; j < num; j++)
3109 fprintf(stdout, ":%.2f", results[D_EVP][j]);
3110 fprintf(stdout, "\n");
3113 "The 'numbers' are in 1000s of bytes per second processed.\n");
3114 fprintf(stdout, "type ");
3115 for (j = 0; j < num; j++)
3116 fprintf(stdout, "%7d bytes", mblengths[j]);
3117 fprintf(stdout, "\n");
3118 fprintf(stdout, "%-24s", alg_name);
3120 for (j = 0; j < num; j++) {
3121 if (results[D_EVP][j] > 10000)
3122 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
3124 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
3126 fprintf(stdout, "\n");
3131 EVP_CIPHER_CTX_free(ctx);