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;
1196 int loopargs_len = 0;
1198 const EVP_CIPHER *evp_cipher = NULL;
1201 int multiblock = 0, doit[ALGOR_NUM], pr_header = 0;
1202 #ifndef OPENSSL_NO_DSA
1203 int dsa_doit[DSA_NUM];
1205 int rsa_doit[RSA_NUM];
1206 int ret = 1, i, k, misalign = 0;
1207 long c[ALGOR_NUM][SIZE_NUM], count = 0, save_count = 0;
1212 /* What follows are the buffers and key material. */
1213 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA)
1216 #ifndef OPENSSL_NO_RC5
1219 #ifndef OPENSSL_NO_RC2
1222 #ifndef OPENSSL_NO_IDEA
1223 IDEA_KEY_SCHEDULE idea_ks;
1225 #ifndef OPENSSL_NO_SEED
1226 SEED_KEY_SCHEDULE seed_ks;
1228 #ifndef OPENSSL_NO_BF
1231 #ifndef OPENSSL_NO_CAST
1234 static const unsigned char key16[16] = {
1235 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1236 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1238 static const unsigned char key24[24] = {
1239 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1240 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1241 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1243 static const unsigned char key32[32] = {
1244 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1245 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1246 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1247 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1249 #ifndef OPENSSL_NO_CAMELLIA
1250 static const unsigned char ckey24[24] = {
1251 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1252 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1253 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1255 static const unsigned char ckey32[32] = {
1256 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1257 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1258 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1259 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1261 CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
1263 #ifndef OPENSSL_NO_DES
1264 static DES_cblock key = {
1265 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
1267 static DES_cblock key2 = {
1268 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1270 static DES_cblock key3 = {
1271 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1274 #ifndef OPENSSL_NO_RSA
1275 static unsigned int rsa_bits[RSA_NUM] = {
1276 512, 1024, 2048, 3072, 4096, 7680, 15360
1278 static unsigned char *rsa_data[RSA_NUM] = {
1279 test512, test1024, test2048, test3072, test4096, test7680, test15360
1281 static int rsa_data_length[RSA_NUM] = {
1282 sizeof(test512), sizeof(test1024),
1283 sizeof(test2048), sizeof(test3072),
1284 sizeof(test4096), sizeof(test7680),
1288 #ifndef OPENSSL_NO_DSA
1289 static unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
1291 #ifndef OPENSSL_NO_EC
1293 * We only test over the following curves as they are representative, To
1294 * add tests over more curves, simply add the curve NID and curve name to
1295 * the following arrays and increase the EC_NUM value accordingly.
1297 static unsigned int test_curves[EC_NUM] = {
1299 NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
1300 NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
1302 NID_sect163k1, NID_sect233k1, NID_sect283k1,
1303 NID_sect409k1, NID_sect571k1, NID_sect163r2,
1304 NID_sect233r1, NID_sect283r1, NID_sect409r1,
1309 static const char *test_curves_names[EC_NUM] = {
1311 "secp160r1", "nistp192", "nistp224",
1312 "nistp256", "nistp384", "nistp521",
1314 "nistk163", "nistk233", "nistk283",
1315 "nistk409", "nistk571", "nistb163",
1316 "nistb233", "nistb283", "nistb409",
1321 static int test_curves_bits[EC_NUM] = {
1327 571, 253 /* X25519 */
1330 #ifndef OPENSSL_NO_EC
1331 int ecdsa_doit[EC_NUM];
1332 int secret_size_a, secret_size_b;
1333 int ecdh_checks = 1;
1335 long ecdh_c[EC_NUM][2];
1336 int ecdh_doit[EC_NUM];
1339 memset(results, 0, sizeof(results));
1341 memset(c, 0, sizeof(c));
1342 #ifndef OPENSSL_NO_DES
1343 memset(DES_iv, 0, sizeof(DES_iv));
1345 memset(iv, 0, sizeof(iv));
1347 for (i = 0; i < ALGOR_NUM; i++)
1349 for (i = 0; i < RSA_NUM; i++)
1351 #ifndef OPENSSL_NO_DSA
1352 for (i = 0; i < DSA_NUM; i++)
1355 #ifndef OPENSSL_NO_EC
1356 for (i = 0; i < EC_NUM; i++)
1358 for (i = 0; i < EC_NUM; i++)
1364 prog = opt_init(argc, argv, speed_options);
1365 while ((o = opt_next()) != OPT_EOF) {
1370 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
1373 opt_help(speed_options);
1380 evp_cipher = EVP_get_cipherbyname(opt_arg());
1381 if (evp_cipher == NULL)
1382 evp_md = EVP_get_digestbyname(opt_arg());
1383 if (evp_cipher == NULL && evp_md == NULL) {
1385 "%s: %s an unknown cipher or digest\n",
1396 * In a forked execution, an engine might need to be
1397 * initialised by each child process, not by the parent.
1398 * So store the name here and run setup_engine() later on.
1400 engine_id = opt_arg();
1404 multi = atoi(opt_arg());
1408 #ifndef OPENSSL_NO_ASYNC
1409 async_jobs = atoi(opt_arg());
1410 if (!ASYNC_is_capable()) {
1412 "%s: async_jobs specified but async not supported\n",
1419 if (!opt_int(opt_arg(), &misalign))
1421 if (misalign > MISALIGN) {
1423 "%s: Maximum offset is %d\n", prog, MISALIGN);
1435 argc = opt_num_rest();
1438 /* Remaining arguments are algorithms. */
1439 for ( ; *argv; argv++) {
1440 if (found(*argv, doit_choices, &i)) {
1444 #ifndef OPENSSL_NO_DES
1445 if (strcmp(*argv, "des") == 0) {
1446 doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
1450 if (strcmp(*argv, "sha") == 0) {
1451 doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
1454 #ifndef OPENSSL_NO_RSA
1456 if (strcmp(*argv, "openssl") == 0) {
1457 RSA_set_default_method(RSA_PKCS1_OpenSSL());
1461 if (strcmp(*argv, "rsa") == 0) {
1462 rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
1463 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
1464 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
1465 rsa_doit[R_RSA_15360] = 1;
1468 if (found(*argv, rsa_choices, &i)) {
1473 #ifndef OPENSSL_NO_DSA
1474 if (strcmp(*argv, "dsa") == 0) {
1475 dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
1476 dsa_doit[R_DSA_2048] = 1;
1479 if (found(*argv, dsa_choices, &i)) {
1484 if (strcmp(*argv, "aes") == 0) {
1485 doit[D_CBC_128_AES] = doit[D_CBC_192_AES] =
1486 doit[D_CBC_256_AES] = 1;
1489 #ifndef OPENSSL_NO_CAMELLIA
1490 if (strcmp(*argv, "camellia") == 0) {
1491 doit[D_CBC_128_CML] = doit[D_CBC_192_CML] =
1492 doit[D_CBC_256_CML] = 1;
1496 #ifndef OPENSSL_NO_EC
1497 if (strcmp(*argv, "ecdsa") == 0) {
1498 for (i = 0; i < EC_NUM; i++)
1502 if (found(*argv, ecdsa_choices, &i)) {
1506 if (strcmp(*argv, "ecdh") == 0) {
1507 for (i = 0; i < EC_NUM; i++)
1511 if (found(*argv, ecdh_choices, &i)) {
1516 BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
1520 /* Initialize the job pool if async mode is enabled */
1521 if (async_jobs > 0) {
1522 async_init = ASYNC_init_thread(async_jobs, async_jobs);
1524 BIO_printf(bio_err, "Error creating the ASYNC job pool\n");
1529 loopargs_len = (async_jobs == 0 ? 1 : async_jobs);
1530 loopargs = app_malloc(loopargs_len * sizeof(loopargs_t), "array of loopargs");
1531 memset(loopargs, 0, loopargs_len * sizeof(loopargs_t));
1533 for (i = 0; i < loopargs_len; i++) {
1534 if (async_jobs > 0) {
1535 loopargs[i].wait_ctx = ASYNC_WAIT_CTX_new();
1536 if (loopargs[i].wait_ctx == NULL) {
1537 BIO_printf(bio_err, "Error creating the ASYNC_WAIT_CTX\n");
1542 loopargs[i].buf_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1543 loopargs[i].buf2_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1544 /* Align the start of buffers on a 64 byte boundary */
1545 loopargs[i].buf = loopargs[i].buf_malloc + misalign;
1546 loopargs[i].buf2 = loopargs[i].buf2_malloc + misalign;
1547 loopargs[i].siglen = app_malloc(sizeof(unsigned int), "signature length");
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);
1645 #ifndef OPENSSL_NO_RSA
1646 memset(rsa_c, 0, sizeof(rsa_c));
1649 # ifndef OPENSSL_NO_DES
1650 BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1656 for (it = count; it; it--)
1657 DES_ecb_encrypt((DES_cblock *)loopargs[0].buf,
1658 (DES_cblock *)loopargs[0].buf, &sch, DES_ENCRYPT);
1662 c[D_MD2][0] = count / 10;
1663 c[D_MDC2][0] = count / 10;
1664 c[D_MD4][0] = count;
1665 c[D_MD5][0] = count;
1666 c[D_HMAC][0] = count;
1667 c[D_SHA1][0] = count;
1668 c[D_RMD160][0] = count;
1669 c[D_RC4][0] = count * 5;
1670 c[D_CBC_DES][0] = count;
1671 c[D_EDE3_DES][0] = count / 3;
1672 c[D_CBC_IDEA][0] = count;
1673 c[D_CBC_SEED][0] = count;
1674 c[D_CBC_RC2][0] = count;
1675 c[D_CBC_RC5][0] = count;
1676 c[D_CBC_BF][0] = count;
1677 c[D_CBC_CAST][0] = count;
1678 c[D_CBC_128_AES][0] = count;
1679 c[D_CBC_192_AES][0] = count;
1680 c[D_CBC_256_AES][0] = count;
1681 c[D_CBC_128_CML][0] = count;
1682 c[D_CBC_192_CML][0] = count;
1683 c[D_CBC_256_CML][0] = count;
1684 c[D_SHA256][0] = count;
1685 c[D_SHA512][0] = count;
1686 c[D_WHIRLPOOL][0] = count;
1687 c[D_IGE_128_AES][0] = count;
1688 c[D_IGE_192_AES][0] = count;
1689 c[D_IGE_256_AES][0] = count;
1690 c[D_GHASH][0] = count;
1692 for (i = 1; i < SIZE_NUM; i++) {
1695 l0 = (long)lengths[0];
1696 l1 = (long)lengths[i];
1698 c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1699 c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1700 c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1701 c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1702 c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1703 c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1704 c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1705 c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1706 c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1707 c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1708 c[D_GHASH][i] = c[D_GHASH][0] * 4 * l0 / l1;
1710 l0 = (long)lengths[i - 1];
1712 c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1713 c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1714 c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1715 c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1716 c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1717 c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1718 c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1719 c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1720 c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1721 c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1722 c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1723 c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1724 c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1725 c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1726 c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1727 c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1728 c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1729 c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1732 # ifndef OPENSSL_NO_RSA
1733 rsa_c[R_RSA_512][0] = count / 2000;
1734 rsa_c[R_RSA_512][1] = count / 400;
1735 for (i = 1; i < RSA_NUM; i++) {
1736 rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1737 rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1738 if ((rsa_doit[i] <= 1) && (rsa_c[i][0] == 0))
1741 if (rsa_c[i][0] == 0) {
1749 # ifndef OPENSSL_NO_DSA
1750 dsa_c[R_DSA_512][0] = count / 1000;
1751 dsa_c[R_DSA_512][1] = count / 1000 / 2;
1752 for (i = 1; i < DSA_NUM; i++) {
1753 dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1754 dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1755 if ((dsa_doit[i] <= 1) && (dsa_c[i][0] == 0))
1758 if (dsa_c[i] == 0) {
1766 # ifndef OPENSSL_NO_EC
1767 ecdsa_c[R_EC_P160][0] = count / 1000;
1768 ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1769 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1770 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1771 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1772 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1775 if (ecdsa_c[i] == 0) {
1781 ecdsa_c[R_EC_K163][0] = count / 1000;
1782 ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1783 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1784 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1785 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1786 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1789 if (ecdsa_c[i] == 0) {
1795 ecdsa_c[R_EC_B163][0] = count / 1000;
1796 ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1797 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1798 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1799 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1800 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1803 if (ecdsa_c[i] == 0) {
1810 ecdh_c[R_EC_P160][0] = count / 1000;
1811 ecdh_c[R_EC_P160][1] = count / 1000;
1812 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1813 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1814 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1815 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1818 if (ecdh_c[i] == 0) {
1824 ecdh_c[R_EC_K163][0] = count / 1000;
1825 ecdh_c[R_EC_K163][1] = count / 1000;
1826 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1827 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1828 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1829 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1832 if (ecdh_c[i] == 0) {
1838 ecdh_c[R_EC_B163][0] = count / 1000;
1839 ecdh_c[R_EC_B163][1] = count / 1000;
1840 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1841 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1842 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1843 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1846 if (ecdh_c[i] == 0) {
1855 /* not worth fixing */
1856 # error "You cannot disable DES on systems without SIGALRM."
1857 # endif /* OPENSSL_NO_DES */
1860 signal(SIGALRM, sig_done);
1862 #endif /* SIGALRM */
1864 #ifndef OPENSSL_NO_MD2
1866 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1867 print_message(names[D_MD2], c[D_MD2][testnum], lengths[testnum]);
1869 count = run_benchmark(async_jobs, EVP_Digest_MD2_loop, loopargs);
1871 print_result(D_MD2, testnum, count, d);
1875 #ifndef OPENSSL_NO_MDC2
1877 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1878 print_message(names[D_MDC2], c[D_MDC2][testnum], lengths[testnum]);
1880 count = run_benchmark(async_jobs, EVP_Digest_MDC2_loop, loopargs);
1882 print_result(D_MDC2, testnum, count, d);
1887 #ifndef OPENSSL_NO_MD4
1889 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1890 print_message(names[D_MD4], c[D_MD4][testnum], lengths[testnum]);
1892 count = run_benchmark(async_jobs, EVP_Digest_MD4_loop, loopargs);
1894 print_result(D_MD4, testnum, count, d);
1899 #ifndef OPENSSL_NO_MD5
1901 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1902 print_message(names[D_MD5], c[D_MD5][testnum], lengths[testnum]);
1904 count = run_benchmark(async_jobs, MD5_loop, loopargs);
1906 print_result(D_MD5, testnum, count, d);
1911 #ifndef OPENSSL_NO_MD5
1913 for (i = 0; i < loopargs_len; i++) {
1914 loopargs[i].hctx = HMAC_CTX_new();
1915 if (loopargs[i].hctx == NULL) {
1916 BIO_printf(bio_err, "HMAC malloc failure, exiting...");
1920 HMAC_Init_ex(loopargs[i].hctx, (unsigned char *)"This is a key...",
1921 16, EVP_md5(), NULL);
1923 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1924 print_message(names[D_HMAC], c[D_HMAC][testnum], lengths[testnum]);
1926 count = run_benchmark(async_jobs, HMAC_loop, loopargs);
1928 print_result(D_HMAC, testnum, count, d);
1930 for (i = 0; i < loopargs_len; i++) {
1931 HMAC_CTX_free(loopargs[i].hctx);
1936 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1937 print_message(names[D_SHA1], c[D_SHA1][testnum], lengths[testnum]);
1939 count = run_benchmark(async_jobs, SHA1_loop, loopargs);
1941 print_result(D_SHA1, testnum, count, d);
1944 if (doit[D_SHA256]) {
1945 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1946 print_message(names[D_SHA256], c[D_SHA256][testnum], lengths[testnum]);
1948 count = run_benchmark(async_jobs, SHA256_loop, loopargs);
1950 print_result(D_SHA256, testnum, count, d);
1953 if (doit[D_SHA512]) {
1954 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1955 print_message(names[D_SHA512], c[D_SHA512][testnum], lengths[testnum]);
1957 count = run_benchmark(async_jobs, SHA512_loop, loopargs);
1959 print_result(D_SHA512, testnum, count, d);
1963 #ifndef OPENSSL_NO_WHIRLPOOL
1964 if (doit[D_WHIRLPOOL]) {
1965 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1966 print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][testnum], lengths[testnum]);
1968 count = run_benchmark(async_jobs, WHIRLPOOL_loop, loopargs);
1970 print_result(D_WHIRLPOOL, testnum, count, d);
1975 #ifndef OPENSSL_NO_RMD160
1976 if (doit[D_RMD160]) {
1977 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1978 print_message(names[D_RMD160], c[D_RMD160][testnum], lengths[testnum]);
1980 count = run_benchmark(async_jobs, EVP_Digest_RMD160_loop, loopargs);
1982 print_result(D_RMD160, testnum, count, d);
1986 #ifndef OPENSSL_NO_RC4
1988 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1989 print_message(names[D_RC4], c[D_RC4][testnum], lengths[testnum]);
1991 count = run_benchmark(async_jobs, RC4_loop, loopargs);
1993 print_result(D_RC4, testnum, count, d);
1997 #ifndef OPENSSL_NO_DES
1998 if (doit[D_CBC_DES]) {
1999 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2000 print_message(names[D_CBC_DES], c[D_CBC_DES][testnum], lengths[testnum]);
2002 count = run_benchmark(async_jobs, DES_ncbc_encrypt_loop, loopargs);
2004 print_result(D_CBC_DES, testnum, count, d);
2008 if (doit[D_EDE3_DES]) {
2009 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2010 print_message(names[D_EDE3_DES], c[D_EDE3_DES][testnum], lengths[testnum]);
2012 count = run_benchmark(async_jobs, DES_ede3_cbc_encrypt_loop, loopargs);
2014 print_result(D_EDE3_DES, testnum, count, d);
2019 if (doit[D_CBC_128_AES]) {
2020 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2021 print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][testnum],
2024 count = run_benchmark(async_jobs, AES_cbc_128_encrypt_loop, loopargs);
2026 print_result(D_CBC_128_AES, testnum, count, d);
2029 if (doit[D_CBC_192_AES]) {
2030 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2031 print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][testnum],
2034 count = run_benchmark(async_jobs, AES_cbc_192_encrypt_loop, loopargs);
2036 print_result(D_CBC_192_AES, testnum, count, d);
2039 if (doit[D_CBC_256_AES]) {
2040 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2041 print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][testnum],
2044 count = run_benchmark(async_jobs, AES_cbc_256_encrypt_loop, loopargs);
2046 print_result(D_CBC_256_AES, testnum, count, d);
2050 if (doit[D_IGE_128_AES]) {
2051 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2052 print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][testnum],
2055 count = run_benchmark(async_jobs, AES_ige_128_encrypt_loop, loopargs);
2057 print_result(D_IGE_128_AES, testnum, count, d);
2060 if (doit[D_IGE_192_AES]) {
2061 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2062 print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][testnum],
2065 count = run_benchmark(async_jobs, AES_ige_192_encrypt_loop, loopargs);
2067 print_result(D_IGE_192_AES, testnum, count, d);
2070 if (doit[D_IGE_256_AES]) {
2071 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2072 print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][testnum],
2075 count = run_benchmark(async_jobs, AES_ige_256_encrypt_loop, loopargs);
2077 print_result(D_IGE_256_AES, testnum, count, d);
2080 if (doit[D_GHASH]) {
2081 for (i = 0; i < loopargs_len; i++) {
2082 loopargs[i].gcm_ctx = CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
2083 CRYPTO_gcm128_setiv(loopargs[i].gcm_ctx, (unsigned char *)"0123456789ab", 12);
2086 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2087 print_message(names[D_GHASH], c[D_GHASH][testnum], lengths[testnum]);
2089 count = run_benchmark(async_jobs, CRYPTO_gcm128_aad_loop, loopargs);
2091 print_result(D_GHASH, testnum, count, d);
2093 for (i = 0; i < loopargs_len; i++)
2094 CRYPTO_gcm128_release(loopargs[i].gcm_ctx);
2097 #ifndef OPENSSL_NO_CAMELLIA
2098 if (doit[D_CBC_128_CML]) {
2099 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2100 print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][testnum],
2102 if (async_jobs > 0) {
2103 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2107 for (count = 0, run = 1; COND(c[D_CBC_128_CML][testnum]); count++)
2108 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2109 (unsigned long)lengths[testnum], &camellia_ks1,
2110 iv, CAMELLIA_ENCRYPT);
2112 print_result(D_CBC_128_CML, testnum, count, d);
2115 if (doit[D_CBC_192_CML]) {
2116 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2117 print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][testnum],
2119 if (async_jobs > 0) {
2120 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2124 for (count = 0, run = 1; COND(c[D_CBC_192_CML][testnum]); count++)
2125 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2126 (unsigned long)lengths[testnum], &camellia_ks2,
2127 iv, CAMELLIA_ENCRYPT);
2129 print_result(D_CBC_192_CML, testnum, count, d);
2132 if (doit[D_CBC_256_CML]) {
2133 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2134 print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][testnum],
2136 if (async_jobs > 0) {
2137 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2141 for (count = 0, run = 1; COND(c[D_CBC_256_CML][testnum]); count++)
2142 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2143 (unsigned long)lengths[testnum], &camellia_ks3,
2144 iv, CAMELLIA_ENCRYPT);
2146 print_result(D_CBC_256_CML, testnum, count, d);
2150 #ifndef OPENSSL_NO_IDEA
2151 if (doit[D_CBC_IDEA]) {
2152 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2153 print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][testnum], lengths[testnum]);
2154 if (async_jobs > 0) {
2155 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2159 for (count = 0, run = 1; COND(c[D_CBC_IDEA][testnum]); count++)
2160 IDEA_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2161 (unsigned long)lengths[testnum], &idea_ks,
2164 print_result(D_CBC_IDEA, testnum, count, d);
2168 #ifndef OPENSSL_NO_SEED
2169 if (doit[D_CBC_SEED]) {
2170 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2171 print_message(names[D_CBC_SEED], c[D_CBC_SEED][testnum], lengths[testnum]);
2172 if (async_jobs > 0) {
2173 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2177 for (count = 0, run = 1; COND(c[D_CBC_SEED][testnum]); count++)
2178 SEED_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2179 (unsigned long)lengths[testnum], &seed_ks, iv, 1);
2181 print_result(D_CBC_SEED, testnum, count, d);
2185 #ifndef OPENSSL_NO_RC2
2186 if (doit[D_CBC_RC2]) {
2187 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2188 print_message(names[D_CBC_RC2], c[D_CBC_RC2][testnum], lengths[testnum]);
2189 if (async_jobs > 0) {
2190 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2194 for (count = 0, run = 1; COND(c[D_CBC_RC2][testnum]); count++)
2195 RC2_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2196 (unsigned long)lengths[testnum], &rc2_ks,
2199 print_result(D_CBC_RC2, testnum, count, d);
2203 #ifndef OPENSSL_NO_RC5
2204 if (doit[D_CBC_RC5]) {
2205 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2206 print_message(names[D_CBC_RC5], c[D_CBC_RC5][testnum], lengths[testnum]);
2207 if (async_jobs > 0) {
2208 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2212 for (count = 0, run = 1; COND(c[D_CBC_RC5][testnum]); count++)
2213 RC5_32_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2214 (unsigned long)lengths[testnum], &rc5_ks,
2217 print_result(D_CBC_RC5, testnum, count, d);
2221 #ifndef OPENSSL_NO_BF
2222 if (doit[D_CBC_BF]) {
2223 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2224 print_message(names[D_CBC_BF], c[D_CBC_BF][testnum], lengths[testnum]);
2225 if (async_jobs > 0) {
2226 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2230 for (count = 0, run = 1; COND(c[D_CBC_BF][testnum]); count++)
2231 BF_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2232 (unsigned long)lengths[testnum], &bf_ks,
2235 print_result(D_CBC_BF, testnum, count, d);
2239 #ifndef OPENSSL_NO_CAST
2240 if (doit[D_CBC_CAST]) {
2241 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2242 print_message(names[D_CBC_CAST], c[D_CBC_CAST][testnum], lengths[testnum]);
2243 if (async_jobs > 0) {
2244 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2248 for (count = 0, run = 1; COND(c[D_CBC_CAST][testnum]); count++)
2249 CAST_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2250 (unsigned long)lengths[testnum], &cast_ks,
2253 print_result(D_CBC_CAST, testnum, count, d);
2259 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
2260 if (multiblock && evp_cipher) {
2262 (EVP_CIPHER_flags(evp_cipher) &
2263 EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
2264 BIO_printf(bio_err, "%s is not multi-block capable\n",
2265 OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
2268 if (async_jobs > 0) {
2269 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2272 multiblock_speed(evp_cipher);
2277 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2280 names[D_EVP] = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
2282 * -O3 -fschedule-insns messes up an optimization here!
2283 * names[D_EVP] somehow becomes NULL
2285 print_message(names[D_EVP], save_count, lengths[testnum]);
2287 for (k = 0; k < loopargs_len; k++) {
2288 loopargs[k].ctx = EVP_CIPHER_CTX_new();
2290 EVP_DecryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2292 EVP_EncryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2293 EVP_CIPHER_CTX_set_padding(loopargs[k].ctx, 0);
2297 count = run_benchmark(async_jobs, EVP_Update_loop, loopargs);
2299 for (k = 0; k < loopargs_len; k++) {
2300 EVP_CIPHER_CTX_free(loopargs[k].ctx);
2304 names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
2305 print_message(names[D_EVP], save_count, lengths[testnum]);
2307 count = run_benchmark(async_jobs, EVP_Digest_loop, loopargs);
2310 print_result(D_EVP, testnum, count, d);
2314 for (i = 0; i < loopargs_len; i++)
2315 RAND_bytes(loopargs[i].buf, 36);
2317 #ifndef OPENSSL_NO_RSA
2318 for (testnum = 0; testnum < RSA_NUM; testnum++) {
2320 if (!rsa_doit[testnum])
2322 for (i = 0; i < loopargs_len; i++) {
2323 st = RSA_sign(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2324 loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2330 "RSA sign failure. No RSA sign will be done.\n");
2331 ERR_print_errors(bio_err);
2334 pkey_print_message("private", "rsa",
2335 rsa_c[testnum][0], rsa_bits[testnum], RSA_SECONDS);
2336 /* RSA_blinding_on(rsa_key[testnum],NULL); */
2338 count = run_benchmark(async_jobs, RSA_sign_loop, loopargs);
2341 mr ? "+R1:%ld:%d:%.2f\n"
2342 : "%ld %d bit private RSA's in %.2fs\n",
2343 count, rsa_bits[testnum], d);
2344 rsa_results[testnum][0] = d / (double)count;
2348 for (i = 0; i < loopargs_len; i++) {
2349 st = RSA_verify(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2350 *(loopargs[i].siglen), loopargs[i].rsa_key[testnum]);
2356 "RSA verify failure. No RSA verify will be done.\n");
2357 ERR_print_errors(bio_err);
2358 rsa_doit[testnum] = 0;
2360 pkey_print_message("public", "rsa",
2361 rsa_c[testnum][1], rsa_bits[testnum], RSA_SECONDS);
2363 count = run_benchmark(async_jobs, RSA_verify_loop, loopargs);
2366 mr ? "+R2:%ld:%d:%.2f\n"
2367 : "%ld %d bit public RSA's in %.2fs\n",
2368 count, rsa_bits[testnum], d);
2369 rsa_results[testnum][1] = d / (double)count;
2372 if (rsa_count <= 1) {
2373 /* if longer than 10s, don't do any more */
2374 for (testnum++; testnum < RSA_NUM; testnum++)
2375 rsa_doit[testnum] = 0;
2380 for (i = 0; i < loopargs_len; i++)
2381 RAND_bytes(loopargs[i].buf, 36);
2383 #ifndef OPENSSL_NO_DSA
2384 if (RAND_status() != 1) {
2385 RAND_seed(rnd_seed, sizeof rnd_seed);
2387 for (testnum = 0; testnum < DSA_NUM; testnum++) {
2389 if (!dsa_doit[testnum])
2392 /* DSA_generate_key(dsa_key[testnum]); */
2393 /* DSA_sign_setup(dsa_key[testnum],NULL); */
2394 for (i = 0; i < loopargs_len; i++) {
2395 st = DSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2396 loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2402 "DSA sign failure. No DSA sign will be done.\n");
2403 ERR_print_errors(bio_err);
2406 pkey_print_message("sign", "dsa",
2407 dsa_c[testnum][0], dsa_bits[testnum], DSA_SECONDS);
2409 count = run_benchmark(async_jobs, DSA_sign_loop, loopargs);
2412 mr ? "+R3:%ld:%d:%.2f\n"
2413 : "%ld %d bit DSA signs in %.2fs\n",
2414 count, dsa_bits[testnum], d);
2415 dsa_results[testnum][0] = d / (double)count;
2419 for (i = 0; i < loopargs_len; i++) {
2420 st = DSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2421 *(loopargs[i].siglen), loopargs[i].dsa_key[testnum]);
2427 "DSA verify failure. No DSA verify will be done.\n");
2428 ERR_print_errors(bio_err);
2429 dsa_doit[testnum] = 0;
2431 pkey_print_message("verify", "dsa",
2432 dsa_c[testnum][1], dsa_bits[testnum], DSA_SECONDS);
2434 count = run_benchmark(async_jobs, DSA_verify_loop, loopargs);
2437 mr ? "+R4:%ld:%d:%.2f\n"
2438 : "%ld %d bit DSA verify in %.2fs\n",
2439 count, dsa_bits[testnum], d);
2440 dsa_results[testnum][1] = d / (double)count;
2443 if (rsa_count <= 1) {
2444 /* if longer than 10s, don't do any more */
2445 for (testnum++; testnum < DSA_NUM; testnum++)
2446 dsa_doit[testnum] = 0;
2451 #ifndef OPENSSL_NO_EC
2452 if (RAND_status() != 1) {
2453 RAND_seed(rnd_seed, sizeof rnd_seed);
2455 for (testnum = 0; testnum < EC_NUM; testnum++) {
2458 if (!ecdsa_doit[testnum])
2459 continue; /* Ignore Curve */
2460 for (i = 0; i < loopargs_len; i++) {
2461 loopargs[i].ecdsa[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2462 if (loopargs[i].ecdsa[testnum] == NULL) {
2468 BIO_printf(bio_err, "ECDSA failure.\n");
2469 ERR_print_errors(bio_err);
2472 for (i = 0; i < loopargs_len; i++) {
2473 EC_KEY_precompute_mult(loopargs[i].ecdsa[testnum], NULL);
2474 /* Perform ECDSA signature test */
2475 EC_KEY_generate_key(loopargs[i].ecdsa[testnum]);
2476 st = ECDSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2477 loopargs[i].siglen, loopargs[i].ecdsa[testnum]);
2483 "ECDSA sign failure. No ECDSA sign will be done.\n");
2484 ERR_print_errors(bio_err);
2487 pkey_print_message("sign", "ecdsa",
2488 ecdsa_c[testnum][0],
2489 test_curves_bits[testnum], ECDSA_SECONDS);
2491 count = run_benchmark(async_jobs, ECDSA_sign_loop, loopargs);
2495 mr ? "+R5:%ld:%d:%.2f\n" :
2496 "%ld %d bit ECDSA signs in %.2fs \n",
2497 count, test_curves_bits[testnum], d);
2498 ecdsa_results[testnum][0] = d / (double)count;
2502 /* Perform ECDSA verification test */
2503 for (i = 0; i < loopargs_len; i++) {
2504 st = ECDSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2505 *(loopargs[i].siglen), loopargs[i].ecdsa[testnum]);
2511 "ECDSA verify failure. No ECDSA verify will be done.\n");
2512 ERR_print_errors(bio_err);
2513 ecdsa_doit[testnum] = 0;
2515 pkey_print_message("verify", "ecdsa",
2516 ecdsa_c[testnum][1],
2517 test_curves_bits[testnum], ECDSA_SECONDS);
2519 count = run_benchmark(async_jobs, ECDSA_verify_loop, loopargs);
2522 mr ? "+R6:%ld:%d:%.2f\n"
2523 : "%ld %d bit ECDSA verify in %.2fs\n",
2524 count, test_curves_bits[testnum], d);
2525 ecdsa_results[testnum][1] = d / (double)count;
2528 if (rsa_count <= 1) {
2529 /* if longer than 10s, don't do any more */
2530 for (testnum++; testnum < EC_NUM; testnum++)
2531 ecdsa_doit[testnum] = 0;
2537 #ifndef OPENSSL_NO_EC
2538 if (RAND_status() != 1) {
2539 RAND_seed(rnd_seed, sizeof rnd_seed);
2541 for (testnum = 0; testnum < EC_NUM; testnum++) {
2542 if (!ecdh_doit[testnum])
2544 for (i = 0; i < loopargs_len; i++) {
2545 loopargs[i].ecdh_a[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2546 loopargs[i].ecdh_b[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2547 if (loopargs[i].ecdh_a[testnum] == NULL ||
2548 loopargs[i].ecdh_b[testnum] == NULL) {
2553 if (ecdh_checks == 0) {
2554 BIO_printf(bio_err, "ECDH failure.\n");
2555 ERR_print_errors(bio_err);
2558 for (i = 0; i < loopargs_len; i++) {
2559 /* generate two ECDH key pairs */
2560 if (!EC_KEY_generate_key(loopargs[i].ecdh_a[testnum]) ||
2561 !EC_KEY_generate_key(loopargs[i].ecdh_b[testnum])) {
2562 BIO_printf(bio_err, "ECDH key generation failure.\n");
2563 ERR_print_errors(bio_err);
2568 * If field size is not more than 24 octets, then use SHA-1
2569 * hash of result; otherwise, use result (see section 4.8 of
2570 * draft-ietf-tls-ecc-03.txt).
2574 EC_GROUP_get_degree(EC_KEY_get0_group(loopargs[i].ecdh_a[testnum]));
2575 if (field_size <= 24 * 8) {
2576 outlen = KDF1_SHA1_len;
2579 outlen = (field_size + 7) / 8;
2583 ECDH_compute_key(loopargs[i].secret_a, outlen,
2584 EC_KEY_get0_public_key(loopargs[i].ecdh_b[testnum]),
2585 loopargs[i].ecdh_a[testnum], kdf);
2587 ECDH_compute_key(loopargs[i].secret_b, outlen,
2588 EC_KEY_get0_public_key(loopargs[i].ecdh_a[testnum]),
2589 loopargs[i].ecdh_b[testnum], kdf);
2590 if (secret_size_a != secret_size_b)
2595 for (secret_idx = 0; (secret_idx < secret_size_a)
2596 && (ecdh_checks == 1); secret_idx++) {
2597 if (loopargs[i].secret_a[secret_idx] != loopargs[i].secret_b[secret_idx])
2601 if (ecdh_checks == 0) {
2602 BIO_printf(bio_err, "ECDH computations don't match.\n");
2603 ERR_print_errors(bio_err);
2609 if (ecdh_checks != 0) {
2610 pkey_print_message("", "ecdh",
2612 test_curves_bits[testnum], ECDH_SECONDS);
2614 count = run_benchmark(async_jobs, ECDH_compute_key_loop, loopargs);
2617 mr ? "+R7:%ld:%d:%.2f\n" :
2618 "%ld %d-bit ECDH ops in %.2fs\n", count,
2619 test_curves_bits[testnum], d);
2620 ecdh_results[testnum][0] = d / (double)count;
2625 if (rsa_count <= 1) {
2626 /* if longer than 10s, don't do any more */
2627 for (testnum++; testnum < EC_NUM; testnum++)
2628 ecdh_doit[testnum] = 0;
2636 printf("%s\n", OpenSSL_version(OPENSSL_VERSION));
2637 printf("%s\n", OpenSSL_version(OPENSSL_BUILT_ON));
2639 printf("%s ", BN_options());
2640 #ifndef OPENSSL_NO_MD2
2641 printf("%s ", MD2_options());
2643 #ifndef OPENSSL_NO_RC4
2644 printf("%s ", RC4_options());
2646 #ifndef OPENSSL_NO_DES
2647 printf("%s ", DES_options());
2649 printf("%s ", AES_options());
2650 #ifndef OPENSSL_NO_IDEA
2651 printf("%s ", IDEA_options());
2653 #ifndef OPENSSL_NO_BF
2654 printf("%s ", BF_options());
2656 printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
2664 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2667 for (testnum = 0; testnum < SIZE_NUM; testnum++)
2668 printf(mr ? ":%d" : "%7d bytes", lengths[testnum]);
2672 for (k = 0; k < ALGOR_NUM; k++) {
2676 printf("+F:%d:%s", k, names[k]);
2678 printf("%-13s", names[k]);
2679 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2680 if (results[k][testnum] > 10000 && !mr)
2681 printf(" %11.2fk", results[k][testnum] / 1e3);
2683 printf(mr ? ":%.2f" : " %11.2f ", results[k][testnum]);
2687 #ifndef OPENSSL_NO_RSA
2689 for (k = 0; k < RSA_NUM; k++) {
2692 if (testnum && !mr) {
2693 printf("%18ssign verify sign/s verify/s\n", " ");
2697 printf("+F2:%u:%u:%f:%f\n",
2698 k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2700 printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2701 rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2702 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2705 #ifndef OPENSSL_NO_DSA
2707 for (k = 0; k < DSA_NUM; k++) {
2710 if (testnum && !mr) {
2711 printf("%18ssign verify sign/s verify/s\n", " ");
2715 printf("+F3:%u:%u:%f:%f\n",
2716 k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2718 printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2719 dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2720 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2723 #ifndef OPENSSL_NO_EC
2725 for (k = 0; k < EC_NUM; k++) {
2728 if (testnum && !mr) {
2729 printf("%30ssign verify sign/s verify/s\n", " ");
2734 printf("+F4:%u:%u:%f:%f\n",
2735 k, test_curves_bits[k],
2736 ecdsa_results[k][0], ecdsa_results[k][1]);
2738 printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2739 test_curves_bits[k],
2740 test_curves_names[k],
2741 ecdsa_results[k][0], ecdsa_results[k][1],
2742 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2746 #ifndef OPENSSL_NO_EC
2748 for (k = 0; k < EC_NUM; k++) {
2751 if (testnum && !mr) {
2752 printf("%30sop op/s\n", " ");
2756 printf("+F5:%u:%u:%f:%f\n",
2757 k, test_curves_bits[k],
2758 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2761 printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2762 test_curves_bits[k],
2763 test_curves_names[k],
2764 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2771 ERR_print_errors(bio_err);
2772 for (i = 0; i < loopargs_len; i++) {
2773 OPENSSL_free(loopargs[i].buf_malloc);
2774 OPENSSL_free(loopargs[i].buf2_malloc);
2775 OPENSSL_free(loopargs[i].siglen);
2777 #ifndef OPENSSL_NO_RSA
2778 for (i = 0; i < loopargs_len; i++) {
2779 for (k = 0; k < RSA_NUM; k++)
2780 RSA_free(loopargs[i].rsa_key[k]);
2783 #ifndef OPENSSL_NO_DSA
2784 for (i = 0; i < loopargs_len; i++) {
2785 for (k = 0; k < DSA_NUM; k++)
2786 DSA_free(loopargs[i].dsa_key[k]);
2790 #ifndef OPENSSL_NO_EC
2791 for (i = 0; i < loopargs_len; i++) {
2792 for (k = 0; k < EC_NUM; k++) {
2793 EC_KEY_free(loopargs[i].ecdsa[k]);
2794 EC_KEY_free(loopargs[i].ecdh_a[k]);
2795 EC_KEY_free(loopargs[i].ecdh_b[k]);
2797 OPENSSL_free(loopargs[i].secret_a);
2798 OPENSSL_free(loopargs[i].secret_b);
2801 if (async_jobs > 0) {
2802 for (i = 0; i < loopargs_len; i++)
2803 ASYNC_WAIT_CTX_free(loopargs[i].wait_ctx);
2807 ASYNC_cleanup_thread();
2809 OPENSSL_free(loopargs);
2813 static void print_message(const char *s, long num, int length)
2817 mr ? "+DT:%s:%d:%d\n"
2818 : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2819 (void)BIO_flush(bio_err);
2823 mr ? "+DN:%s:%ld:%d\n"
2824 : "Doing %s %ld times on %d size blocks: ", s, num, length);
2825 (void)BIO_flush(bio_err);
2829 static void pkey_print_message(const char *str, const char *str2, long num,
2834 mr ? "+DTP:%d:%s:%s:%d\n"
2835 : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2836 (void)BIO_flush(bio_err);
2840 mr ? "+DNP:%ld:%d:%s:%s\n"
2841 : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2842 (void)BIO_flush(bio_err);
2846 static void print_result(int alg, int run_no, int count, double time_used)
2849 mr ? "+R:%d:%s:%f\n"
2850 : "%d %s's in %.2fs\n", count, names[alg], time_used);
2851 results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2855 static char *sstrsep(char **string, const char *delim)
2858 char *token = *string;
2863 memset(isdelim, 0, sizeof isdelim);
2867 isdelim[(unsigned char)(*delim)] = 1;
2871 while (!isdelim[(unsigned char)(**string)]) {
2883 static int do_multi(int multi)
2888 static char sep[] = ":";
2890 fds = malloc(sizeof(*fds) * multi);
2891 for (n = 0; n < multi; ++n) {
2892 if (pipe(fd) == -1) {
2893 BIO_printf(bio_err, "pipe failure\n");
2897 (void)BIO_flush(bio_err);
2904 if (dup(fd[1]) == -1) {
2905 BIO_printf(bio_err, "dup failed\n");
2914 printf("Forked child %d\n", n);
2917 /* for now, assume the pipe is long enough to take all the output */
2918 for (n = 0; n < multi; ++n) {
2923 f = fdopen(fds[n], "r");
2924 while (fgets(buf, sizeof buf, f)) {
2925 p = strchr(buf, '\n');
2928 if (buf[0] != '+') {
2929 BIO_printf(bio_err, "Don't understand line '%s' from child %d\n",
2933 printf("Got: %s from %d\n", buf, n);
2934 if (strncmp(buf, "+F:", 3) == 0) {
2939 alg = atoi(sstrsep(&p, sep));
2941 for (j = 0; j < SIZE_NUM; ++j)
2942 results[alg][j] += atof(sstrsep(&p, sep));
2943 } else if (strncmp(buf, "+F2:", 4) == 0) {
2948 k = atoi(sstrsep(&p, sep));
2951 d = atof(sstrsep(&p, sep));
2953 rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
2955 rsa_results[k][0] = d;
2957 d = atof(sstrsep(&p, sep));
2959 rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
2961 rsa_results[k][1] = d;
2963 # ifndef OPENSSL_NO_DSA
2964 else if (strncmp(buf, "+F3:", 4) == 0) {
2969 k = atoi(sstrsep(&p, sep));
2972 d = atof(sstrsep(&p, sep));
2974 dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
2976 dsa_results[k][0] = d;
2978 d = atof(sstrsep(&p, sep));
2980 dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
2982 dsa_results[k][1] = d;
2985 # ifndef OPENSSL_NO_EC
2986 else if (strncmp(buf, "+F4:", 4) == 0) {
2991 k = atoi(sstrsep(&p, sep));
2994 d = atof(sstrsep(&p, sep));
2996 ecdsa_results[k][0] =
2997 1 / (1 / ecdsa_results[k][0] + 1 / d);
2999 ecdsa_results[k][0] = d;
3001 d = atof(sstrsep(&p, sep));
3003 ecdsa_results[k][1] =
3004 1 / (1 / ecdsa_results[k][1] + 1 / d);
3006 ecdsa_results[k][1] = d;
3010 # ifndef OPENSSL_NO_EC
3011 else if (strncmp(buf, "+F5:", 4) == 0) {
3016 k = atoi(sstrsep(&p, sep));
3019 d = atof(sstrsep(&p, sep));
3021 ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
3023 ecdh_results[k][0] = d;
3028 else if (strncmp(buf, "+H:", 3) == 0) {
3031 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf, n);
3041 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
3043 static int mblengths[] =
3044 { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
3045 int j, count, num = OSSL_NELEM(mblengths);
3046 const char *alg_name;
3047 unsigned char *inp, *out, no_key[32], no_iv[16];
3048 EVP_CIPHER_CTX *ctx;
3051 inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
3052 out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
3053 ctx = EVP_CIPHER_CTX_new();
3054 EVP_EncryptInit_ex(ctx, evp_cipher, NULL, no_key, no_iv);
3055 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key),
3057 alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
3059 for (j = 0; j < num; j++) {
3060 print_message(alg_name, 0, mblengths[j]);
3062 for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
3063 unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
3064 EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
3065 size_t len = mblengths[j];
3068 memset(aad, 0, 8); /* avoid uninitialized values */
3069 aad[8] = 23; /* SSL3_RT_APPLICATION_DATA */
3070 aad[9] = 3; /* version */
3072 aad[11] = 0; /* length */
3074 mb_param.out = NULL;
3077 mb_param.interleave = 8;
3079 packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
3080 sizeof(mb_param), &mb_param);
3086 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
3087 sizeof(mb_param), &mb_param);
3091 RAND_bytes(out, 16);
3095 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
3096 EVP_AEAD_TLS1_AAD_LEN, aad);
3097 EVP_Cipher(ctx, out, inp, len + pad);
3101 BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
3102 : "%d %s's in %.2fs\n", count, "evp", d);
3103 results[D_EVP][j] = ((double)count) / d * mblengths[j];
3107 fprintf(stdout, "+H");
3108 for (j = 0; j < num; j++)
3109 fprintf(stdout, ":%d", mblengths[j]);
3110 fprintf(stdout, "\n");
3111 fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
3112 for (j = 0; j < num; j++)
3113 fprintf(stdout, ":%.2f", results[D_EVP][j]);
3114 fprintf(stdout, "\n");
3117 "The 'numbers' are in 1000s of bytes per second processed.\n");
3118 fprintf(stdout, "type ");
3119 for (j = 0; j < num; j++)
3120 fprintf(stdout, "%7d bytes", mblengths[j]);
3121 fprintf(stdout, "\n");
3122 fprintf(stdout, "%-24s", alg_name);
3124 for (j = 0; j < num; j++) {
3125 if (results[D_EVP][j] > 10000)
3126 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
3128 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
3130 fprintf(stdout, "\n");
3135 EVP_CIPHER_CTX_free(ctx);