2 * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
4 * Licensed under the OpenSSL license (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
10 /* ====================================================================
11 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
13 * Portions of the attached software ("Contribution") are developed by
14 * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
16 * The Contribution is licensed pursuant to the OpenSSL open source
17 * license provided above.
19 * The ECDH and ECDSA speed test software is originally written by
20 * Sumit Gupta of Sun Microsystems Laboratories.
26 #define PRIME_SECONDS 10
27 #define RSA_SECONDS 10
28 #define DSA_SECONDS 10
29 #define ECDSA_SECONDS 10
30 #define ECDH_SECONDS 10
37 #include <openssl/crypto.h>
38 #include <openssl/rand.h>
39 #include <openssl/err.h>
40 #include <openssl/evp.h>
41 #include <openssl/objects.h>
42 #include <openssl/async.h>
43 #if !defined(OPENSSL_SYS_MSDOS)
44 # include OPENSSL_UNISTD
51 #include <openssl/bn.h>
52 #ifndef OPENSSL_NO_DES
53 # include <openssl/des.h>
55 #include <openssl/aes.h>
56 #ifndef OPENSSL_NO_CAMELLIA
57 # include <openssl/camellia.h>
59 #ifndef OPENSSL_NO_MD2
60 # include <openssl/md2.h>
62 #ifndef OPENSSL_NO_MDC2
63 # include <openssl/mdc2.h>
65 #ifndef OPENSSL_NO_MD4
66 # include <openssl/md4.h>
68 #ifndef OPENSSL_NO_MD5
69 # include <openssl/md5.h>
71 #include <openssl/hmac.h>
72 #include <openssl/sha.h>
73 #ifndef OPENSSL_NO_RMD160
74 # include <openssl/ripemd.h>
76 #ifndef OPENSSL_NO_WHIRLPOOL
77 # include <openssl/whrlpool.h>
79 #ifndef OPENSSL_NO_RC4
80 # include <openssl/rc4.h>
82 #ifndef OPENSSL_NO_RC5
83 # include <openssl/rc5.h>
85 #ifndef OPENSSL_NO_RC2
86 # include <openssl/rc2.h>
88 #ifndef OPENSSL_NO_IDEA
89 # include <openssl/idea.h>
91 #ifndef OPENSSL_NO_SEED
92 # include <openssl/seed.h>
95 # include <openssl/blowfish.h>
97 #ifndef OPENSSL_NO_CAST
98 # include <openssl/cast.h>
100 #ifndef OPENSSL_NO_RSA
101 # include <openssl/rsa.h>
102 # include "./testrsa.h"
104 #include <openssl/x509.h>
105 #ifndef OPENSSL_NO_DSA
106 # include <openssl/dsa.h>
107 # include "./testdsa.h"
109 #ifndef OPENSSL_NO_EC
110 # include <openssl/ec.h>
112 #include <openssl/modes.h>
115 # if defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_WINDOWS)
129 #define BUFSIZE (1024*16+1)
130 #define MAX_MISALIGNMENT 63
139 #define MAX_ECDH_SIZE 256
142 static volatile int run = 0;
145 static int usertime = 1;
147 typedef void *(*kdf_fn) (const void *in, size_t inlen, void *out,
150 typedef struct loopargs_st {
151 ASYNC_JOB *inprogress_job;
152 ASYNC_WAIT_CTX *wait_ctx;
155 unsigned char *buf_malloc;
156 unsigned char *buf2_malloc;
158 #ifndef OPENSSL_NO_RSA
159 RSA *rsa_key[RSA_NUM];
161 #ifndef OPENSSL_NO_DSA
162 DSA *dsa_key[DSA_NUM];
164 #ifndef OPENSSL_NO_EC
165 EC_KEY *ecdsa[EC_NUM];
166 EVP_PKEY_CTX *ecdh_ctx[EC_NUM];
167 unsigned char *secret_a;
168 unsigned char *secret_b;
169 size_t outlen[EC_NUM];
174 GCM128_CONTEXT *gcm_ctx;
177 #ifndef OPENSSL_NO_MD2
178 static int EVP_Digest_MD2_loop(void *args);
181 #ifndef OPENSSL_NO_MDC2
182 static int EVP_Digest_MDC2_loop(void *args);
184 #ifndef OPENSSL_NO_MD4
185 static int EVP_Digest_MD4_loop(void *args);
187 #ifndef OPENSSL_NO_MD5
188 static int MD5_loop(void *args);
189 static int HMAC_loop(void *args);
191 static int SHA1_loop(void *args);
192 static int SHA256_loop(void *args);
193 static int SHA512_loop(void *args);
194 #ifndef OPENSSL_NO_WHIRLPOOL
195 static int WHIRLPOOL_loop(void *args);
197 #ifndef OPENSSL_NO_RMD160
198 static int EVP_Digest_RMD160_loop(void *args);
200 #ifndef OPENSSL_NO_RC4
201 static int RC4_loop(void *args);
203 #ifndef OPENSSL_NO_DES
204 static int DES_ncbc_encrypt_loop(void *args);
205 static int DES_ede3_cbc_encrypt_loop(void *args);
207 static int AES_cbc_128_encrypt_loop(void *args);
208 static int AES_cbc_192_encrypt_loop(void *args);
209 static int AES_ige_128_encrypt_loop(void *args);
210 static int AES_cbc_256_encrypt_loop(void *args);
211 static int AES_ige_192_encrypt_loop(void *args);
212 static int AES_ige_256_encrypt_loop(void *args);
213 static int CRYPTO_gcm128_aad_loop(void *args);
214 static int EVP_Update_loop(void *args);
215 static int EVP_Digest_loop(void *args);
216 #ifndef OPENSSL_NO_RSA
217 static int RSA_sign_loop(void *args);
218 static int RSA_verify_loop(void *args);
220 #ifndef OPENSSL_NO_DSA
221 static int DSA_sign_loop(void *args);
222 static int DSA_verify_loop(void *args);
224 #ifndef OPENSSL_NO_EC
225 static int ECDSA_sign_loop(void *args);
226 static int ECDSA_verify_loop(void *args);
228 static int run_benchmark(int async_jobs, int (*loop_function) (void *),
229 loopargs_t * loopargs);
231 static double Time_F(int s);
232 static void print_message(const char *s, long num, int length);
233 static void pkey_print_message(const char *str, const char *str2,
234 long num, int bits, int sec);
235 static void print_result(int alg, int run_no, int count, double time_used);
237 static int do_multi(int multi);
240 static const char *names[ALGOR_NUM] = {
241 "md2", "mdc2", "md4", "md5", "hmac(md5)", "sha1", "rmd160", "rc4",
242 "des cbc", "des ede3", "idea cbc", "seed cbc",
243 "rc2 cbc", "rc5-32/12 cbc", "blowfish cbc", "cast cbc",
244 "aes-128 cbc", "aes-192 cbc", "aes-256 cbc",
245 "camellia-128 cbc", "camellia-192 cbc", "camellia-256 cbc",
246 "evp", "sha256", "sha512", "whirlpool",
247 "aes-128 ige", "aes-192 ige", "aes-256 ige", "ghash"
250 static double results[ALGOR_NUM][SIZE_NUM];
252 static const int lengths[SIZE_NUM] = {
253 16, 64, 256, 1024, 8 * 1024, 16 * 1024
256 #ifndef OPENSSL_NO_RSA
257 static double rsa_results[RSA_NUM][2];
259 #ifndef OPENSSL_NO_DSA
260 static double dsa_results[DSA_NUM][2];
262 #ifndef OPENSSL_NO_EC
263 static double ecdsa_results[EC_NUM][2];
264 static double ecdh_results[EC_NUM][1];
267 #if !defined(OPENSSL_NO_DSA) || !defined(OPENSSL_NO_EC)
268 static const char rnd_seed[] =
269 "string to make the random number generator think it has entropy";
273 # if defined(__STDC__) || defined(sgi) || defined(_AIX)
274 # define SIGRETTYPE void
276 # define SIGRETTYPE int
279 static SIGRETTYPE sig_done(int sig);
280 static SIGRETTYPE sig_done(int sig)
282 signal(SIGALRM, sig_done);
292 # if !defined(SIGALRM)
295 static unsigned int lapse, schlock;
296 static void alarm_win32(unsigned int secs)
301 # define alarm alarm_win32
303 static DWORD WINAPI sleepy(VOID * arg)
311 static double Time_F(int s)
318 thr = CreateThread(NULL, 4096, sleepy, NULL, 0, NULL);
320 DWORD err = GetLastError();
321 BIO_printf(bio_err, "unable to CreateThread (%lu)", err);
325 Sleep(0); /* scheduler spinlock */
326 ret = app_tminterval(s, usertime);
328 ret = app_tminterval(s, usertime);
330 TerminateThread(thr, 0);
338 static double Time_F(int s)
340 double ret = app_tminterval(s, usertime);
347 static void multiblock_speed(const EVP_CIPHER *evp_cipher);
349 static int found(const char *name, const OPT_PAIR *pairs, int *result)
351 for (; pairs->name; pairs++)
352 if (strcmp(name, pairs->name) == 0) {
353 *result = pairs->retval;
359 typedef enum OPTION_choice {
360 OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
361 OPT_ELAPSED, OPT_EVP, OPT_DECRYPT, OPT_ENGINE, OPT_MULTI,
362 OPT_MR, OPT_MB, OPT_MISALIGN, OPT_ASYNCJOBS
365 const OPTIONS speed_options[] = {
366 {OPT_HELP_STR, 1, '-', "Usage: %s [options] ciphers...\n"},
367 {OPT_HELP_STR, 1, '-', "Valid options are:\n"},
368 {"help", OPT_HELP, '-', "Display this summary"},
369 {"evp", OPT_EVP, 's', "Use specified EVP cipher"},
370 {"decrypt", OPT_DECRYPT, '-',
371 "Time decryption instead of encryption (only EVP)"},
372 {"mr", OPT_MR, '-', "Produce machine readable output"},
374 "Enable (tls1.1) multi-block mode on evp_cipher requested with -evp"},
375 {"misalign", OPT_MISALIGN, 'n', "Amount to mis-align buffers"},
376 {"elapsed", OPT_ELAPSED, '-',
377 "Measure time in real time instead of CPU user time"},
379 {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"},
381 #ifndef OPENSSL_NO_ASYNC
382 {"async_jobs", OPT_ASYNCJOBS, 'p',
383 "Enable async mode and start pnum jobs"},
385 #ifndef OPENSSL_NO_ENGINE
386 {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
401 #define D_CBC_IDEA 10
402 #define D_CBC_SEED 11
406 #define D_CBC_CAST 15
407 #define D_CBC_128_AES 16
408 #define D_CBC_192_AES 17
409 #define D_CBC_256_AES 18
410 #define D_CBC_128_CML 19
411 #define D_CBC_192_CML 20
412 #define D_CBC_256_CML 21
416 #define D_WHIRLPOOL 25
417 #define D_IGE_128_AES 26
418 #define D_IGE_192_AES 27
419 #define D_IGE_256_AES 28
421 static OPT_PAIR doit_choices[] = {
422 #ifndef OPENSSL_NO_MD2
425 #ifndef OPENSSL_NO_MDC2
428 #ifndef OPENSSL_NO_MD4
431 #ifndef OPENSSL_NO_MD5
436 {"sha256", D_SHA256},
437 {"sha512", D_SHA512},
438 #ifndef OPENSSL_NO_WHIRLPOOL
439 {"whirlpool", D_WHIRLPOOL},
441 #ifndef OPENSSL_NO_RMD160
442 {"ripemd", D_RMD160},
443 {"rmd160", D_RMD160},
444 {"ripemd160", D_RMD160},
446 #ifndef OPENSSL_NO_RC4
449 #ifndef OPENSSL_NO_DES
450 {"des-cbc", D_CBC_DES},
451 {"des-ede3", D_EDE3_DES},
453 {"aes-128-cbc", D_CBC_128_AES},
454 {"aes-192-cbc", D_CBC_192_AES},
455 {"aes-256-cbc", D_CBC_256_AES},
456 {"aes-128-ige", D_IGE_128_AES},
457 {"aes-192-ige", D_IGE_192_AES},
458 {"aes-256-ige", D_IGE_256_AES},
459 #ifndef OPENSSL_NO_RC2
460 {"rc2-cbc", D_CBC_RC2},
463 #ifndef OPENSSL_NO_RC5
464 {"rc5-cbc", D_CBC_RC5},
467 #ifndef OPENSSL_NO_IDEA
468 {"idea-cbc", D_CBC_IDEA},
469 {"idea", D_CBC_IDEA},
471 #ifndef OPENSSL_NO_SEED
472 {"seed-cbc", D_CBC_SEED},
473 {"seed", D_CBC_SEED},
475 #ifndef OPENSSL_NO_BF
476 {"bf-cbc", D_CBC_BF},
477 {"blowfish", D_CBC_BF},
480 #ifndef OPENSSL_NO_CAST
481 {"cast-cbc", D_CBC_CAST},
482 {"cast", D_CBC_CAST},
483 {"cast5", D_CBC_CAST},
489 #ifndef OPENSSL_NO_DSA
491 # define R_DSA_1024 1
492 # define R_DSA_2048 2
493 static OPT_PAIR dsa_choices[] = {
494 {"dsa512", R_DSA_512},
495 {"dsa1024", R_DSA_1024},
496 {"dsa2048", R_DSA_2048},
507 #define R_RSA_15360 6
508 static OPT_PAIR rsa_choices[] = {
509 {"rsa512", R_RSA_512},
510 {"rsa1024", R_RSA_1024},
511 {"rsa2048", R_RSA_2048},
512 {"rsa3072", R_RSA_3072},
513 {"rsa4096", R_RSA_4096},
514 {"rsa7680", R_RSA_7680},
515 {"rsa15360", R_RSA_15360},
535 #define R_EC_X25519 16
536 #ifndef OPENSSL_NO_EC
537 static OPT_PAIR ecdsa_choices[] = {
538 {"ecdsap160", R_EC_P160},
539 {"ecdsap192", R_EC_P192},
540 {"ecdsap224", R_EC_P224},
541 {"ecdsap256", R_EC_P256},
542 {"ecdsap384", R_EC_P384},
543 {"ecdsap521", R_EC_P521},
544 {"ecdsak163", R_EC_K163},
545 {"ecdsak233", R_EC_K233},
546 {"ecdsak283", R_EC_K283},
547 {"ecdsak409", R_EC_K409},
548 {"ecdsak571", R_EC_K571},
549 {"ecdsab163", R_EC_B163},
550 {"ecdsab233", R_EC_B233},
551 {"ecdsab283", R_EC_B283},
552 {"ecdsab409", R_EC_B409},
553 {"ecdsab571", R_EC_B571},
557 static OPT_PAIR ecdh_choices[] = {
558 {"ecdhp160", R_EC_P160},
559 {"ecdhp192", R_EC_P192},
560 {"ecdhp224", R_EC_P224},
561 {"ecdhp256", R_EC_P256},
562 {"ecdhp384", R_EC_P384},
563 {"ecdhp521", R_EC_P521},
564 {"ecdhk163", R_EC_K163},
565 {"ecdhk233", R_EC_K233},
566 {"ecdhk283", R_EC_K283},
567 {"ecdhk409", R_EC_K409},
568 {"ecdhk571", R_EC_K571},
569 {"ecdhb163", R_EC_B163},
570 {"ecdhb233", R_EC_B233},
571 {"ecdhb283", R_EC_B283},
572 {"ecdhb409", R_EC_B409},
573 {"ecdhb571", R_EC_B571},
574 {"ecdhx25519", R_EC_X25519},
580 # define COND(d) (count < (d))
581 # define COUNT(d) (d)
583 # define COND(unused_cond) (run && count<0x7fffffff)
584 # define COUNT(d) (count)
589 /* Nb of iterations to do per algorithm and key-size */
590 static long c[ALGOR_NUM][SIZE_NUM];
592 #ifndef OPENSSL_NO_MD2
593 static int EVP_Digest_MD2_loop(void *args)
595 loopargs_t *tempargs = *(loopargs_t **) args;
596 unsigned char *buf = tempargs->buf;
597 unsigned char md2[MD2_DIGEST_LENGTH];
600 for (count = 0; COND(c[D_MD2][testnum]); count++) {
601 if (!EVP_Digest(buf, (size_t)lengths[testnum], md2, NULL, EVP_md2(),
609 #ifndef OPENSSL_NO_MDC2
610 static int EVP_Digest_MDC2_loop(void *args)
612 loopargs_t *tempargs = *(loopargs_t **) args;
613 unsigned char *buf = tempargs->buf;
614 unsigned char mdc2[MDC2_DIGEST_LENGTH];
617 for (count = 0; COND(c[D_MDC2][testnum]); count++) {
618 if (!EVP_Digest(buf, (size_t)lengths[testnum], mdc2, NULL, EVP_mdc2(),
626 #ifndef OPENSSL_NO_MD4
627 static int EVP_Digest_MD4_loop(void *args)
629 loopargs_t *tempargs = *(loopargs_t **) args;
630 unsigned char *buf = tempargs->buf;
631 unsigned char md4[MD4_DIGEST_LENGTH];
634 for (count = 0; COND(c[D_MD4][testnum]); count++) {
635 if (!EVP_Digest(buf, (size_t)lengths[testnum], md4, NULL, EVP_md4(),
643 #ifndef OPENSSL_NO_MD5
644 static int MD5_loop(void *args)
646 loopargs_t *tempargs = *(loopargs_t **) args;
647 unsigned char *buf = tempargs->buf;
648 unsigned char md5[MD5_DIGEST_LENGTH];
650 for (count = 0; COND(c[D_MD5][testnum]); count++)
651 MD5(buf, lengths[testnum], md5);
655 static int HMAC_loop(void *args)
657 loopargs_t *tempargs = *(loopargs_t **) args;
658 unsigned char *buf = tempargs->buf;
659 HMAC_CTX *hctx = tempargs->hctx;
660 unsigned char hmac[MD5_DIGEST_LENGTH];
663 for (count = 0; COND(c[D_HMAC][testnum]); count++) {
664 HMAC_Init_ex(hctx, NULL, 0, NULL, NULL);
665 HMAC_Update(hctx, buf, lengths[testnum]);
666 HMAC_Final(hctx, hmac, NULL);
672 static int SHA1_loop(void *args)
674 loopargs_t *tempargs = *(loopargs_t **) args;
675 unsigned char *buf = tempargs->buf;
676 unsigned char sha[SHA_DIGEST_LENGTH];
678 for (count = 0; COND(c[D_SHA1][testnum]); count++)
679 SHA1(buf, lengths[testnum], sha);
683 static int SHA256_loop(void *args)
685 loopargs_t *tempargs = *(loopargs_t **) args;
686 unsigned char *buf = tempargs->buf;
687 unsigned char sha256[SHA256_DIGEST_LENGTH];
689 for (count = 0; COND(c[D_SHA256][testnum]); count++)
690 SHA256(buf, lengths[testnum], sha256);
694 static int SHA512_loop(void *args)
696 loopargs_t *tempargs = *(loopargs_t **) args;
697 unsigned char *buf = tempargs->buf;
698 unsigned char sha512[SHA512_DIGEST_LENGTH];
700 for (count = 0; COND(c[D_SHA512][testnum]); count++)
701 SHA512(buf, lengths[testnum], sha512);
705 #ifndef OPENSSL_NO_WHIRLPOOL
706 static int WHIRLPOOL_loop(void *args)
708 loopargs_t *tempargs = *(loopargs_t **) args;
709 unsigned char *buf = tempargs->buf;
710 unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];
712 for (count = 0; COND(c[D_WHIRLPOOL][testnum]); count++)
713 WHIRLPOOL(buf, lengths[testnum], whirlpool);
718 #ifndef OPENSSL_NO_RMD160
719 static int EVP_Digest_RMD160_loop(void *args)
721 loopargs_t *tempargs = *(loopargs_t **) args;
722 unsigned char *buf = tempargs->buf;
723 unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
725 for (count = 0; COND(c[D_RMD160][testnum]); count++) {
726 if (!EVP_Digest(buf, (size_t)lengths[testnum], &(rmd160[0]),
727 NULL, EVP_ripemd160(), NULL))
734 #ifndef OPENSSL_NO_RC4
735 static RC4_KEY rc4_ks;
736 static int RC4_loop(void *args)
738 loopargs_t *tempargs = *(loopargs_t **) args;
739 unsigned char *buf = tempargs->buf;
741 for (count = 0; COND(c[D_RC4][testnum]); count++)
742 RC4(&rc4_ks, (size_t)lengths[testnum], buf, buf);
747 #ifndef OPENSSL_NO_DES
748 static unsigned char DES_iv[8];
749 static DES_key_schedule sch;
750 static DES_key_schedule sch2;
751 static DES_key_schedule sch3;
752 static int DES_ncbc_encrypt_loop(void *args)
754 loopargs_t *tempargs = *(loopargs_t **) args;
755 unsigned char *buf = tempargs->buf;
757 for (count = 0; COND(c[D_CBC_DES][testnum]); count++)
758 DES_ncbc_encrypt(buf, buf, lengths[testnum], &sch,
759 &DES_iv, DES_ENCRYPT);
763 static int DES_ede3_cbc_encrypt_loop(void *args)
765 loopargs_t *tempargs = *(loopargs_t **) args;
766 unsigned char *buf = tempargs->buf;
768 for (count = 0; COND(c[D_EDE3_DES][testnum]); count++)
769 DES_ede3_cbc_encrypt(buf, buf, lengths[testnum],
770 &sch, &sch2, &sch3, &DES_iv, DES_ENCRYPT);
775 #define MAX_BLOCK_SIZE 128
777 static unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
778 static AES_KEY aes_ks1, aes_ks2, aes_ks3;
779 static int AES_cbc_128_encrypt_loop(void *args)
781 loopargs_t *tempargs = *(loopargs_t **) args;
782 unsigned char *buf = tempargs->buf;
784 for (count = 0; COND(c[D_CBC_128_AES][testnum]); count++)
785 AES_cbc_encrypt(buf, buf,
786 (size_t)lengths[testnum], &aes_ks1, iv, AES_ENCRYPT);
790 static int AES_cbc_192_encrypt_loop(void *args)
792 loopargs_t *tempargs = *(loopargs_t **) args;
793 unsigned char *buf = tempargs->buf;
795 for (count = 0; COND(c[D_CBC_192_AES][testnum]); count++)
796 AES_cbc_encrypt(buf, buf,
797 (size_t)lengths[testnum], &aes_ks2, iv, AES_ENCRYPT);
801 static int AES_cbc_256_encrypt_loop(void *args)
803 loopargs_t *tempargs = *(loopargs_t **) args;
804 unsigned char *buf = tempargs->buf;
806 for (count = 0; COND(c[D_CBC_256_AES][testnum]); count++)
807 AES_cbc_encrypt(buf, buf,
808 (size_t)lengths[testnum], &aes_ks3, iv, AES_ENCRYPT);
812 static int AES_ige_128_encrypt_loop(void *args)
814 loopargs_t *tempargs = *(loopargs_t **) args;
815 unsigned char *buf = tempargs->buf;
816 unsigned char *buf2 = tempargs->buf2;
818 for (count = 0; COND(c[D_IGE_128_AES][testnum]); count++)
819 AES_ige_encrypt(buf, buf2,
820 (size_t)lengths[testnum], &aes_ks1, iv, AES_ENCRYPT);
824 static int AES_ige_192_encrypt_loop(void *args)
826 loopargs_t *tempargs = *(loopargs_t **) args;
827 unsigned char *buf = tempargs->buf;
828 unsigned char *buf2 = tempargs->buf2;
830 for (count = 0; COND(c[D_IGE_192_AES][testnum]); count++)
831 AES_ige_encrypt(buf, buf2,
832 (size_t)lengths[testnum], &aes_ks2, iv, AES_ENCRYPT);
836 static int AES_ige_256_encrypt_loop(void *args)
838 loopargs_t *tempargs = *(loopargs_t **) args;
839 unsigned char *buf = tempargs->buf;
840 unsigned char *buf2 = tempargs->buf2;
842 for (count = 0; COND(c[D_IGE_256_AES][testnum]); count++)
843 AES_ige_encrypt(buf, buf2,
844 (size_t)lengths[testnum], &aes_ks3, iv, AES_ENCRYPT);
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 long save_count = 0;
860 static int decrypt = 0;
861 static int EVP_Update_loop(void *args)
863 loopargs_t *tempargs = *(loopargs_t **) args;
864 unsigned char *buf = tempargs->buf;
865 EVP_CIPHER_CTX *ctx = tempargs->ctx;
868 int nb_iter = save_count * 4 * lengths[0] / lengths[testnum];
871 for (count = 0; COND(nb_iter); count++)
872 EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
874 for (count = 0; COND(nb_iter); count++)
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 int nb_iter = save_count * 4 * lengths[0] / lengths[testnum];
894 for (count = 0; COND(nb_iter); count++) {
895 if (!EVP_Digest(buf, lengths[testnum], md, NULL, evp_md, NULL))
901 #ifndef OPENSSL_NO_RSA
902 static long rsa_c[RSA_NUM][2]; /* # RSA iteration test */
904 static int RSA_sign_loop(void *args)
906 loopargs_t *tempargs = *(loopargs_t **) args;
907 unsigned char *buf = tempargs->buf;
908 unsigned char *buf2 = tempargs->buf2;
909 unsigned int *rsa_num = &tempargs->siglen;
910 RSA **rsa_key = tempargs->rsa_key;
912 for (count = 0; COND(rsa_c[testnum][0]); count++) {
913 ret = RSA_sign(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
915 BIO_printf(bio_err, "RSA sign failure\n");
916 ERR_print_errors(bio_err);
924 static int RSA_verify_loop(void *args)
926 loopargs_t *tempargs = *(loopargs_t **) args;
927 unsigned char *buf = tempargs->buf;
928 unsigned char *buf2 = tempargs->buf2;
929 unsigned int rsa_num = tempargs->siglen;
930 RSA **rsa_key = tempargs->rsa_key;
932 for (count = 0; COND(rsa_c[testnum][1]); count++) {
934 RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
936 BIO_printf(bio_err, "RSA verify failure\n");
937 ERR_print_errors(bio_err);
946 #ifndef OPENSSL_NO_DSA
947 static long dsa_c[DSA_NUM][2];
948 static int DSA_sign_loop(void *args)
950 loopargs_t *tempargs = *(loopargs_t **) args;
951 unsigned char *buf = tempargs->buf;
952 unsigned char *buf2 = tempargs->buf2;
953 DSA **dsa_key = tempargs->dsa_key;
954 unsigned int *siglen = &tempargs->siglen;
956 for (count = 0; COND(dsa_c[testnum][0]); count++) {
957 ret = DSA_sign(0, buf, 20, buf2, siglen, dsa_key[testnum]);
959 BIO_printf(bio_err, "DSA sign failure\n");
960 ERR_print_errors(bio_err);
968 static int DSA_verify_loop(void *args)
970 loopargs_t *tempargs = *(loopargs_t **) args;
971 unsigned char *buf = tempargs->buf;
972 unsigned char *buf2 = tempargs->buf2;
973 DSA **dsa_key = tempargs->dsa_key;
974 unsigned int siglen = tempargs->siglen;
976 for (count = 0; COND(dsa_c[testnum][1]); count++) {
977 ret = DSA_verify(0, buf, 20, buf2, siglen, dsa_key[testnum]);
979 BIO_printf(bio_err, "DSA verify failure\n");
980 ERR_print_errors(bio_err);
989 #ifndef OPENSSL_NO_EC
990 static long ecdsa_c[EC_NUM][2];
991 static int ECDSA_sign_loop(void *args)
993 loopargs_t *tempargs = *(loopargs_t **) args;
994 unsigned char *buf = tempargs->buf;
995 EC_KEY **ecdsa = tempargs->ecdsa;
996 unsigned char *ecdsasig = tempargs->buf2;
997 unsigned int *ecdsasiglen = &tempargs->siglen;
999 for (count = 0; COND(ecdsa_c[testnum][0]); count++) {
1000 ret = ECDSA_sign(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[testnum]);
1002 BIO_printf(bio_err, "ECDSA sign failure\n");
1003 ERR_print_errors(bio_err);
1011 static int ECDSA_verify_loop(void *args)
1013 loopargs_t *tempargs = *(loopargs_t **) args;
1014 unsigned char *buf = tempargs->buf;
1015 EC_KEY **ecdsa = tempargs->ecdsa;
1016 unsigned char *ecdsasig = tempargs->buf2;
1017 unsigned int ecdsasiglen = tempargs->siglen;
1019 for (count = 0; COND(ecdsa_c[testnum][1]); count++) {
1020 ret = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[testnum]);
1022 BIO_printf(bio_err, "ECDSA verify failure\n");
1023 ERR_print_errors(bio_err);
1031 /* ******************************************************************** */
1032 static long ecdh_c[EC_NUM][1];
1034 static int ECDH_EVP_derive_key(unsigned char *derived_secret,
1035 size_t *outlen, EVP_PKEY_CTX *ctx)
1038 if ((rt = EVP_PKEY_derive(ctx, derived_secret, outlen)) <= 0) {
1039 BIO_printf(bio_err, "ECDH EVP_PKEY_derive failure: returned %d\n", rt);
1040 ERR_print_errors(bio_err);
1046 static int ECDH_EVP_derive_key_loop(void *args)
1048 loopargs_t *tempargs = *(loopargs_t **) args;
1049 EVP_PKEY_CTX *ctx = tempargs->ecdh_ctx[testnum];
1050 unsigned char *derived_secret = tempargs->secret_a;
1052 size_t *outlen = &(tempargs->outlen[testnum]);
1054 for (count = 0; COND(ecdh_c[testnum][0]); count++) {
1055 if (!ECDH_EVP_derive_key(derived_secret, outlen, ctx))
1061 #endif /* OPENSSL_NO_EC */
1063 static int run_benchmark(int async_jobs,
1064 int (*loop_function) (void *), loopargs_t * loopargs)
1066 int job_op_count = 0;
1067 int total_op_count = 0;
1068 int num_inprogress = 0;
1069 int error = 0, i = 0, ret = 0;
1070 OSSL_ASYNC_FD job_fd = 0;
1071 size_t num_job_fds = 0;
1075 if (async_jobs == 0) {
1076 return loop_function((void *)&loopargs);
1079 for (i = 0; i < async_jobs && !error; i++) {
1080 loopargs_t *looparg_item = loopargs + i;
1082 /* Copy pointer content (looparg_t item address) into async context */
1083 ret = ASYNC_start_job(&loopargs[i].inprogress_job, loopargs[i].wait_ctx,
1084 &job_op_count, loop_function,
1085 (void *)&looparg_item, sizeof(looparg_item));
1091 if (job_op_count == -1) {
1094 total_op_count += job_op_count;
1099 BIO_printf(bio_err, "Failure in the job\n");
1100 ERR_print_errors(bio_err);
1106 while (num_inprogress > 0) {
1107 #if defined(OPENSSL_SYS_WINDOWS)
1109 #elif defined(OPENSSL_SYS_UNIX)
1110 int select_result = 0;
1111 OSSL_ASYNC_FD max_fd = 0;
1114 FD_ZERO(&waitfdset);
1116 for (i = 0; i < async_jobs && num_inprogress > 0; i++) {
1117 if (loopargs[i].inprogress_job == NULL)
1120 if (!ASYNC_WAIT_CTX_get_all_fds
1121 (loopargs[i].wait_ctx, NULL, &num_job_fds)
1122 || num_job_fds > 1) {
1123 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1124 ERR_print_errors(bio_err);
1128 ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd,
1130 FD_SET(job_fd, &waitfdset);
1131 if (job_fd > max_fd)
1135 if (max_fd >= (OSSL_ASYNC_FD)FD_SETSIZE) {
1137 "Error: max_fd (%d) must be smaller than FD_SETSIZE (%d). "
1138 "Decrease the value of async_jobs\n",
1139 max_fd, FD_SETSIZE);
1140 ERR_print_errors(bio_err);
1145 select_result = select(max_fd + 1, &waitfdset, NULL, NULL, NULL);
1146 if (select_result == -1 && errno == EINTR)
1149 if (select_result == -1) {
1150 BIO_printf(bio_err, "Failure in the select\n");
1151 ERR_print_errors(bio_err);
1156 if (select_result == 0)
1160 for (i = 0; i < async_jobs; i++) {
1161 if (loopargs[i].inprogress_job == NULL)
1164 if (!ASYNC_WAIT_CTX_get_all_fds
1165 (loopargs[i].wait_ctx, NULL, &num_job_fds)
1166 || num_job_fds > 1) {
1167 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1168 ERR_print_errors(bio_err);
1172 ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd,
1175 #if defined(OPENSSL_SYS_UNIX)
1176 if (num_job_fds == 1 && !FD_ISSET(job_fd, &waitfdset))
1178 #elif defined(OPENSSL_SYS_WINDOWS)
1179 if (num_job_fds == 1
1180 && !PeekNamedPipe(job_fd, NULL, 0, NULL, &avail, NULL)
1185 ret = ASYNC_start_job(&loopargs[i].inprogress_job,
1186 loopargs[i].wait_ctx, &job_op_count,
1187 loop_function, (void *)(loopargs + i),
1188 sizeof(loopargs_t));
1193 if (job_op_count == -1) {
1196 total_op_count += job_op_count;
1199 loopargs[i].inprogress_job = NULL;
1204 loopargs[i].inprogress_job = NULL;
1205 BIO_printf(bio_err, "Failure in the job\n");
1206 ERR_print_errors(bio_err);
1213 return error ? -1 : total_op_count;
1216 int speed_main(int argc, char **argv)
1219 loopargs_t *loopargs = NULL;
1221 int loopargs_len = 0;
1223 const char *engine_id = NULL;
1224 const EVP_CIPHER *evp_cipher = NULL;
1227 int multiblock = 0, pr_header = 0;
1228 int doit[ALGOR_NUM] = { 0 };
1229 int ret = 1, i, k, misalign = 0;
1235 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) \
1236 || !defined(OPENSSL_NO_EC)
1240 /* What follows are the buffers and key material. */
1241 #ifndef OPENSSL_NO_RC5
1244 #ifndef OPENSSL_NO_RC2
1247 #ifndef OPENSSL_NO_IDEA
1248 IDEA_KEY_SCHEDULE idea_ks;
1250 #ifndef OPENSSL_NO_SEED
1251 SEED_KEY_SCHEDULE seed_ks;
1253 #ifndef OPENSSL_NO_BF
1256 #ifndef OPENSSL_NO_CAST
1259 static const unsigned char key16[16] = {
1260 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1261 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1263 static const unsigned char key24[24] = {
1264 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1265 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1266 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1268 static const unsigned char key32[32] = {
1269 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1270 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1271 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1272 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1274 #ifndef OPENSSL_NO_CAMELLIA
1275 static const unsigned char ckey24[24] = {
1276 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1277 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1278 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1280 static const unsigned char ckey32[32] = {
1281 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1282 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1283 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1284 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1286 CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
1288 #ifndef OPENSSL_NO_DES
1289 static DES_cblock key = {
1290 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
1292 static DES_cblock key2 = {
1293 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1295 static DES_cblock key3 = {
1296 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1299 #ifndef OPENSSL_NO_RSA
1300 static const unsigned int rsa_bits[RSA_NUM] = {
1301 512, 1024, 2048, 3072, 4096, 7680, 15360
1303 static const unsigned char *rsa_data[RSA_NUM] = {
1304 test512, test1024, test2048, test3072, test4096, test7680, test15360
1306 static const int rsa_data_length[RSA_NUM] = {
1307 sizeof(test512), sizeof(test1024),
1308 sizeof(test2048), sizeof(test3072),
1309 sizeof(test4096), sizeof(test7680),
1312 int rsa_doit[RSA_NUM] = { 0 };
1314 #ifndef OPENSSL_NO_DSA
1315 static const unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
1316 int dsa_doit[DSA_NUM] = { 0 };
1318 #ifndef OPENSSL_NO_EC
1320 * We only test over the following curves as they are representative, To
1321 * add tests over more curves, simply add the curve NID and curve name to
1322 * the following arrays and increase the EC_NUM value accordingly.
1324 static const unsigned int test_curves[EC_NUM] = {
1326 NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
1327 NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
1329 NID_sect163k1, NID_sect233k1, NID_sect283k1,
1330 NID_sect409k1, NID_sect571k1, NID_sect163r2,
1331 NID_sect233r1, NID_sect283r1, NID_sect409r1,
1336 static const char *test_curves_names[EC_NUM] = {
1338 "secp160r1", "nistp192", "nistp224",
1339 "nistp256", "nistp384", "nistp521",
1341 "nistk163", "nistk233", "nistk283",
1342 "nistk409", "nistk571", "nistb163",
1343 "nistb233", "nistb283", "nistb409",
1348 static const int test_curves_bits[EC_NUM] = {
1354 571, 253 /* X25519 */
1357 int ecdsa_doit[EC_NUM] = { 0 };
1358 int ecdh_doit[EC_NUM] = { 0 };
1359 #endif /* ndef OPENSSL_NO_EC */
1361 prog = opt_init(argc, argv, speed_options);
1362 while ((o = opt_next()) != OPT_EOF) {
1367 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
1370 opt_help(speed_options);
1377 evp_cipher = EVP_get_cipherbyname(opt_arg());
1378 if (evp_cipher == NULL)
1379 evp_md = EVP_get_digestbyname(opt_arg());
1380 if (evp_cipher == NULL && evp_md == NULL) {
1382 "%s: %s is an unknown cipher or digest\n",
1393 * In a forked execution, an engine might need to be
1394 * initialised by each child process, not by the parent.
1395 * So store the name here and run setup_engine() later on.
1397 engine_id = opt_arg();
1401 multi = atoi(opt_arg());
1405 #ifndef OPENSSL_NO_ASYNC
1406 async_jobs = atoi(opt_arg());
1407 if (!ASYNC_is_capable()) {
1409 "%s: async_jobs specified but async not supported\n",
1416 if (!opt_int(opt_arg(), &misalign))
1418 if (misalign > MISALIGN) {
1420 "%s: Maximum offset is %d\n", prog, MISALIGN);
1429 #ifdef OPENSSL_NO_MULTIBLOCK
1431 "%s: -mb specified but multi-block support is disabled\n",
1438 argc = opt_num_rest();
1441 /* Remaining arguments are algorithms. */
1442 for (; *argv; argv++) {
1443 if (found(*argv, doit_choices, &i)) {
1447 #ifndef OPENSSL_NO_DES
1448 if (strcmp(*argv, "des") == 0) {
1449 doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
1453 if (strcmp(*argv, "sha") == 0) {
1454 doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
1457 #ifndef OPENSSL_NO_RSA
1459 if (strcmp(*argv, "openssl") == 0) {
1460 RSA_set_default_method(RSA_PKCS1_OpenSSL());
1464 if (strcmp(*argv, "rsa") == 0) {
1465 rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
1466 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
1467 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
1468 rsa_doit[R_RSA_15360] = 1;
1471 if (found(*argv, rsa_choices, &i)) {
1476 #ifndef OPENSSL_NO_DSA
1477 if (strcmp(*argv, "dsa") == 0) {
1478 dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
1479 dsa_doit[R_DSA_2048] = 1;
1482 if (found(*argv, dsa_choices, &i)) {
1487 if (strcmp(*argv, "aes") == 0) {
1488 doit[D_CBC_128_AES] = doit[D_CBC_192_AES] = doit[D_CBC_256_AES] = 1;
1491 #ifndef OPENSSL_NO_CAMELLIA
1492 if (strcmp(*argv, "camellia") == 0) {
1493 doit[D_CBC_128_CML] = doit[D_CBC_192_CML] = doit[D_CBC_256_CML] = 1;
1497 #ifndef OPENSSL_NO_EC
1498 if (strcmp(*argv, "ecdsa") == 0) {
1499 for (i = 0; i < EC_NUM; i++)
1503 if (found(*argv, ecdsa_choices, &i)) {
1507 if (strcmp(*argv, "ecdh") == 0) {
1508 for (i = 0; i < EC_NUM; i++)
1512 if (found(*argv, ecdh_choices, &i)) {
1517 BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
1521 /* Initialize the job pool if async mode is enabled */
1522 if (async_jobs > 0) {
1523 async_init = ASYNC_init_thread(async_jobs, async_jobs);
1525 BIO_printf(bio_err, "Error creating the ASYNC job pool\n");
1530 loopargs_len = (async_jobs == 0 ? 1 : async_jobs);
1532 app_malloc(loopargs_len * sizeof(loopargs_t), "array of loopargs");
1533 memset(loopargs, 0, loopargs_len * sizeof(loopargs_t));
1535 for (i = 0; i < loopargs_len; i++) {
1536 if (async_jobs > 0) {
1537 loopargs[i].wait_ctx = ASYNC_WAIT_CTX_new();
1538 if (loopargs[i].wait_ctx == NULL) {
1539 BIO_printf(bio_err, "Error creating the ASYNC_WAIT_CTX\n");
1544 loopargs[i].buf_malloc =
1545 app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1546 loopargs[i].buf2_malloc =
1547 app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1548 /* Align the start of buffers on a 64 byte boundary */
1549 loopargs[i].buf = loopargs[i].buf_malloc + misalign;
1550 loopargs[i].buf2 = loopargs[i].buf2_malloc + misalign;
1551 #ifndef OPENSSL_NO_EC
1552 loopargs[i].secret_a = app_malloc(MAX_ECDH_SIZE, "ECDH secret a");
1553 loopargs[i].secret_b = app_malloc(MAX_ECDH_SIZE, "ECDH secret b");
1558 if (multi && do_multi(multi))
1562 /* Initialize the engine after the fork */
1563 e = setup_engine(engine_id, 0);
1565 /* No parameters; turn on everything. */
1566 if ((argc == 0) && !doit[D_EVP]) {
1567 for (i = 0; i < ALGOR_NUM; i++)
1570 #ifndef OPENSSL_NO_RSA
1571 for (i = 0; i < RSA_NUM; i++)
1574 #ifndef OPENSSL_NO_DSA
1575 for (i = 0; i < DSA_NUM; i++)
1578 #ifndef OPENSSL_NO_EC
1579 for (i = 0; i < EC_NUM; i++)
1581 for (i = 0; i < EC_NUM; i++)
1585 for (i = 0; i < ALGOR_NUM; i++)
1589 if (usertime == 0 && !mr)
1591 "You have chosen to measure elapsed time "
1592 "instead of user CPU time.\n");
1594 #ifndef OPENSSL_NO_RSA
1595 for (i = 0; i < loopargs_len; i++) {
1596 for (k = 0; k < RSA_NUM; k++) {
1597 const unsigned char *p;
1600 loopargs[i].rsa_key[k] =
1601 d2i_RSAPrivateKey(NULL, &p, rsa_data_length[k]);
1602 if (loopargs[i].rsa_key[k] == NULL) {
1604 "internal error loading RSA key number %d\n", k);
1610 #ifndef OPENSSL_NO_DSA
1611 for (i = 0; i < loopargs_len; i++) {
1612 loopargs[i].dsa_key[0] = get_dsa512();
1613 loopargs[i].dsa_key[1] = get_dsa1024();
1614 loopargs[i].dsa_key[2] = get_dsa2048();
1617 #ifndef OPENSSL_NO_DES
1618 DES_set_key_unchecked(&key, &sch);
1619 DES_set_key_unchecked(&key2, &sch2);
1620 DES_set_key_unchecked(&key3, &sch3);
1622 AES_set_encrypt_key(key16, 128, &aes_ks1);
1623 AES_set_encrypt_key(key24, 192, &aes_ks2);
1624 AES_set_encrypt_key(key32, 256, &aes_ks3);
1625 #ifndef OPENSSL_NO_CAMELLIA
1626 Camellia_set_key(key16, 128, &camellia_ks1);
1627 Camellia_set_key(ckey24, 192, &camellia_ks2);
1628 Camellia_set_key(ckey32, 256, &camellia_ks3);
1630 #ifndef OPENSSL_NO_IDEA
1631 IDEA_set_encrypt_key(key16, &idea_ks);
1633 #ifndef OPENSSL_NO_SEED
1634 SEED_set_key(key16, &seed_ks);
1636 #ifndef OPENSSL_NO_RC4
1637 RC4_set_key(&rc4_ks, 16, key16);
1639 #ifndef OPENSSL_NO_RC2
1640 RC2_set_key(&rc2_ks, 16, key16, 128);
1642 #ifndef OPENSSL_NO_RC5
1643 RC5_32_set_key(&rc5_ks, 16, key16, 12);
1645 #ifndef OPENSSL_NO_BF
1646 BF_set_key(&bf_ks, 16, key16);
1648 #ifndef OPENSSL_NO_CAST
1649 CAST_set_key(&cast_ks, 16, key16);
1652 # ifndef OPENSSL_NO_DES
1653 BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1659 for (it = count; it; it--)
1660 DES_ecb_encrypt((DES_cblock *)loopargs[0].buf,
1661 (DES_cblock *)loopargs[0].buf, &sch, DES_ENCRYPT);
1665 c[D_MD2][0] = count / 10;
1666 c[D_MDC2][0] = count / 10;
1667 c[D_MD4][0] = count;
1668 c[D_MD5][0] = count;
1669 c[D_HMAC][0] = count;
1670 c[D_SHA1][0] = count;
1671 c[D_RMD160][0] = count;
1672 c[D_RC4][0] = count * 5;
1673 c[D_CBC_DES][0] = count;
1674 c[D_EDE3_DES][0] = count / 3;
1675 c[D_CBC_IDEA][0] = count;
1676 c[D_CBC_SEED][0] = count;
1677 c[D_CBC_RC2][0] = count;
1678 c[D_CBC_RC5][0] = count;
1679 c[D_CBC_BF][0] = count;
1680 c[D_CBC_CAST][0] = count;
1681 c[D_CBC_128_AES][0] = count;
1682 c[D_CBC_192_AES][0] = count;
1683 c[D_CBC_256_AES][0] = count;
1684 c[D_CBC_128_CML][0] = count;
1685 c[D_CBC_192_CML][0] = count;
1686 c[D_CBC_256_CML][0] = count;
1687 c[D_SHA256][0] = count;
1688 c[D_SHA512][0] = count;
1689 c[D_WHIRLPOOL][0] = count;
1690 c[D_IGE_128_AES][0] = count;
1691 c[D_IGE_192_AES][0] = count;
1692 c[D_IGE_256_AES][0] = count;
1693 c[D_GHASH][0] = count;
1695 for (i = 1; i < SIZE_NUM; i++) {
1698 l0 = (long)lengths[0];
1699 l1 = (long)lengths[i];
1701 c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1702 c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1703 c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1704 c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1705 c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1706 c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1707 c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1708 c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1709 c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1710 c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1711 c[D_GHASH][i] = c[D_GHASH][0] * 4 * l0 / l1;
1713 l0 = (long)lengths[i - 1];
1715 c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1716 c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1717 c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1718 c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1719 c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1720 c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1721 c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1722 c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1723 c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1724 c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1725 c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1726 c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1727 c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1728 c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1729 c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1730 c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1731 c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1732 c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1735 # ifndef OPENSSL_NO_RSA
1736 rsa_c[R_RSA_512][0] = count / 2000;
1737 rsa_c[R_RSA_512][1] = count / 400;
1738 for (i = 1; i < RSA_NUM; i++) {
1739 rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1740 rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1741 if (rsa_doit[i] <= 1 && rsa_c[i][0] == 0)
1744 if (rsa_c[i][0] == 0) {
1745 rsa_c[i][0] = 1; /* Set minimum iteration Nb to 1. */
1752 # ifndef OPENSSL_NO_DSA
1753 dsa_c[R_DSA_512][0] = count / 1000;
1754 dsa_c[R_DSA_512][1] = count / 1000 / 2;
1755 for (i = 1; i < DSA_NUM; i++) {
1756 dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1757 dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1758 if (dsa_doit[i] <= 1 && dsa_c[i][0] == 0)
1761 if (dsa_c[i][0] == 0) {
1762 dsa_c[i][0] = 1; /* Set minimum iteration Nb to 1. */
1769 # ifndef OPENSSL_NO_EC
1770 ecdsa_c[R_EC_P160][0] = count / 1000;
1771 ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1772 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1773 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1774 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1775 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1778 if (ecdsa_c[i][0] == 0) {
1784 ecdsa_c[R_EC_K163][0] = count / 1000;
1785 ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1786 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1787 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1788 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1789 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1792 if (ecdsa_c[i][0] == 0) {
1798 ecdsa_c[R_EC_B163][0] = count / 1000;
1799 ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1800 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1801 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1802 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1803 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1806 if (ecdsa_c[i][0] == 0) {
1813 ecdh_c[R_EC_P160][0] = count / 1000;
1814 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1815 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1816 if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1819 if (ecdh_c[i][0] == 0) {
1824 ecdh_c[R_EC_K163][0] = count / 1000;
1825 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1826 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1827 if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1830 if (ecdh_c[i][0] == 0) {
1835 ecdh_c[R_EC_B163][0] = count / 1000;
1836 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1837 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1838 if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1841 if (ecdh_c[i][0] == 0) {
1849 /* not worth fixing */
1850 # error "You cannot disable DES on systems without SIGALRM."
1851 # endif /* OPENSSL_NO_DES */
1854 signal(SIGALRM, sig_done);
1856 #endif /* SIGALRM */
1858 #ifndef OPENSSL_NO_MD2
1860 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1861 print_message(names[D_MD2], c[D_MD2][testnum], lengths[testnum]);
1863 count = run_benchmark(async_jobs, EVP_Digest_MD2_loop, loopargs);
1865 print_result(D_MD2, testnum, count, d);
1869 #ifndef OPENSSL_NO_MDC2
1871 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1872 print_message(names[D_MDC2], c[D_MDC2][testnum], lengths[testnum]);
1874 count = run_benchmark(async_jobs, EVP_Digest_MDC2_loop, loopargs);
1876 print_result(D_MDC2, testnum, count, d);
1881 #ifndef OPENSSL_NO_MD4
1883 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1884 print_message(names[D_MD4], c[D_MD4][testnum], lengths[testnum]);
1886 count = run_benchmark(async_jobs, EVP_Digest_MD4_loop, loopargs);
1888 print_result(D_MD4, testnum, count, d);
1893 #ifndef OPENSSL_NO_MD5
1895 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1896 print_message(names[D_MD5], c[D_MD5][testnum], lengths[testnum]);
1898 count = run_benchmark(async_jobs, MD5_loop, loopargs);
1900 print_result(D_MD5, testnum, count, d);
1905 static const char hmac_key[] = "This is a key...";
1906 int len = strlen(hmac_key);
1908 for (i = 0; i < loopargs_len; i++) {
1909 loopargs[i].hctx = HMAC_CTX_new();
1910 if (loopargs[i].hctx == NULL) {
1911 BIO_printf(bio_err, "HMAC malloc failure, exiting...");
1915 HMAC_Init_ex(loopargs[i].hctx, hmac_key, len, EVP_md5(), NULL);
1917 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1918 print_message(names[D_HMAC], c[D_HMAC][testnum], lengths[testnum]);
1920 count = run_benchmark(async_jobs, HMAC_loop, loopargs);
1922 print_result(D_HMAC, testnum, count, d);
1924 for (i = 0; i < loopargs_len; i++) {
1925 HMAC_CTX_free(loopargs[i].hctx);
1930 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1931 print_message(names[D_SHA1], c[D_SHA1][testnum], lengths[testnum]);
1933 count = run_benchmark(async_jobs, SHA1_loop, loopargs);
1935 print_result(D_SHA1, testnum, count, d);
1938 if (doit[D_SHA256]) {
1939 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1940 print_message(names[D_SHA256], c[D_SHA256][testnum],
1943 count = run_benchmark(async_jobs, SHA256_loop, loopargs);
1945 print_result(D_SHA256, testnum, count, d);
1948 if (doit[D_SHA512]) {
1949 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1950 print_message(names[D_SHA512], c[D_SHA512][testnum],
1953 count = run_benchmark(async_jobs, SHA512_loop, loopargs);
1955 print_result(D_SHA512, testnum, count, d);
1958 #ifndef OPENSSL_NO_WHIRLPOOL
1959 if (doit[D_WHIRLPOOL]) {
1960 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1961 print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][testnum],
1964 count = run_benchmark(async_jobs, WHIRLPOOL_loop, loopargs);
1966 print_result(D_WHIRLPOOL, testnum, count, d);
1971 #ifndef OPENSSL_NO_RMD160
1972 if (doit[D_RMD160]) {
1973 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1974 print_message(names[D_RMD160], c[D_RMD160][testnum],
1977 count = run_benchmark(async_jobs, EVP_Digest_RMD160_loop, loopargs);
1979 print_result(D_RMD160, testnum, count, d);
1983 #ifndef OPENSSL_NO_RC4
1985 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1986 print_message(names[D_RC4], c[D_RC4][testnum], lengths[testnum]);
1988 count = run_benchmark(async_jobs, RC4_loop, loopargs);
1990 print_result(D_RC4, testnum, count, d);
1994 #ifndef OPENSSL_NO_DES
1995 if (doit[D_CBC_DES]) {
1996 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1997 print_message(names[D_CBC_DES], c[D_CBC_DES][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],
2012 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],
2025 run_benchmark(async_jobs, AES_cbc_128_encrypt_loop, loopargs);
2027 print_result(D_CBC_128_AES, testnum, count, d);
2030 if (doit[D_CBC_192_AES]) {
2031 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2032 print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][testnum],
2036 run_benchmark(async_jobs, AES_cbc_192_encrypt_loop, loopargs);
2038 print_result(D_CBC_192_AES, testnum, count, d);
2041 if (doit[D_CBC_256_AES]) {
2042 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2043 print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][testnum],
2047 run_benchmark(async_jobs, AES_cbc_256_encrypt_loop, loopargs);
2049 print_result(D_CBC_256_AES, testnum, count, d);
2053 if (doit[D_IGE_128_AES]) {
2054 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2055 print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][testnum],
2059 run_benchmark(async_jobs, AES_ige_128_encrypt_loop, loopargs);
2061 print_result(D_IGE_128_AES, testnum, count, d);
2064 if (doit[D_IGE_192_AES]) {
2065 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2066 print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][testnum],
2070 run_benchmark(async_jobs, AES_ige_192_encrypt_loop, loopargs);
2072 print_result(D_IGE_192_AES, testnum, count, d);
2075 if (doit[D_IGE_256_AES]) {
2076 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2077 print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][testnum],
2081 run_benchmark(async_jobs, AES_ige_256_encrypt_loop, loopargs);
2083 print_result(D_IGE_256_AES, testnum, count, d);
2086 if (doit[D_GHASH]) {
2087 for (i = 0; i < loopargs_len; i++) {
2088 loopargs[i].gcm_ctx =
2089 CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
2090 CRYPTO_gcm128_setiv(loopargs[i].gcm_ctx,
2091 (unsigned char *)"0123456789ab", 12);
2094 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2095 print_message(names[D_GHASH], c[D_GHASH][testnum],
2098 count = run_benchmark(async_jobs, CRYPTO_gcm128_aad_loop, loopargs);
2100 print_result(D_GHASH, testnum, count, d);
2102 for (i = 0; i < loopargs_len; i++)
2103 CRYPTO_gcm128_release(loopargs[i].gcm_ctx);
2105 #ifndef OPENSSL_NO_CAMELLIA
2106 if (doit[D_CBC_128_CML]) {
2107 if (async_jobs > 0) {
2108 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2109 names[D_CBC_128_CML]);
2110 doit[D_CBC_128_CML] = 0;
2112 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2113 print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][testnum],
2116 for (count = 0, run = 1; COND(c[D_CBC_128_CML][testnum]); count++)
2117 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2118 (size_t)lengths[testnum], &camellia_ks1,
2119 iv, CAMELLIA_ENCRYPT);
2121 print_result(D_CBC_128_CML, testnum, count, d);
2124 if (doit[D_CBC_192_CML]) {
2125 if (async_jobs > 0) {
2126 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2127 names[D_CBC_192_CML]);
2128 doit[D_CBC_192_CML] = 0;
2130 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2131 print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][testnum],
2133 if (async_jobs > 0) {
2134 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2138 for (count = 0, run = 1; COND(c[D_CBC_192_CML][testnum]); count++)
2139 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2140 (size_t)lengths[testnum], &camellia_ks2,
2141 iv, CAMELLIA_ENCRYPT);
2143 print_result(D_CBC_192_CML, testnum, count, d);
2146 if (doit[D_CBC_256_CML]) {
2147 if (async_jobs > 0) {
2148 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2149 names[D_CBC_256_CML]);
2150 doit[D_CBC_256_CML] = 0;
2152 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2153 print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][testnum],
2156 for (count = 0, run = 1; COND(c[D_CBC_256_CML][testnum]); count++)
2157 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2158 (size_t)lengths[testnum], &camellia_ks3,
2159 iv, CAMELLIA_ENCRYPT);
2161 print_result(D_CBC_256_CML, testnum, count, d);
2165 #ifndef OPENSSL_NO_IDEA
2166 if (doit[D_CBC_IDEA]) {
2167 if (async_jobs > 0) {
2168 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2170 doit[D_CBC_IDEA] = 0;
2172 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2173 print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][testnum],
2176 for (count = 0, run = 1; COND(c[D_CBC_IDEA][testnum]); count++)
2177 IDEA_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2178 (size_t)lengths[testnum], &idea_ks,
2181 print_result(D_CBC_IDEA, testnum, count, d);
2185 #ifndef OPENSSL_NO_SEED
2186 if (doit[D_CBC_SEED]) {
2187 if (async_jobs > 0) {
2188 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2190 doit[D_CBC_SEED] = 0;
2192 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2193 print_message(names[D_CBC_SEED], c[D_CBC_SEED][testnum],
2196 for (count = 0, run = 1; COND(c[D_CBC_SEED][testnum]); count++)
2197 SEED_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2198 (size_t)lengths[testnum], &seed_ks, iv, 1);
2200 print_result(D_CBC_SEED, testnum, count, d);
2204 #ifndef OPENSSL_NO_RC2
2205 if (doit[D_CBC_RC2]) {
2206 if (async_jobs > 0) {
2207 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2209 doit[D_CBC_RC2] = 0;
2211 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2212 print_message(names[D_CBC_RC2], c[D_CBC_RC2][testnum],
2214 if (async_jobs > 0) {
2215 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2219 for (count = 0, run = 1; COND(c[D_CBC_RC2][testnum]); count++)
2220 RC2_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2221 (size_t)lengths[testnum], &rc2_ks,
2224 print_result(D_CBC_RC2, testnum, count, d);
2228 #ifndef OPENSSL_NO_RC5
2229 if (doit[D_CBC_RC5]) {
2230 if (async_jobs > 0) {
2231 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2233 doit[D_CBC_RC5] = 0;
2235 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2236 print_message(names[D_CBC_RC5], c[D_CBC_RC5][testnum],
2238 if (async_jobs > 0) {
2239 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2243 for (count = 0, run = 1; COND(c[D_CBC_RC5][testnum]); count++)
2244 RC5_32_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2245 (size_t)lengths[testnum], &rc5_ks,
2248 print_result(D_CBC_RC5, testnum, count, d);
2252 #ifndef OPENSSL_NO_BF
2253 if (doit[D_CBC_BF]) {
2254 if (async_jobs > 0) {
2255 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2259 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2260 print_message(names[D_CBC_BF], c[D_CBC_BF][testnum],
2263 for (count = 0, run = 1; COND(c[D_CBC_BF][testnum]); count++)
2264 BF_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2265 (size_t)lengths[testnum], &bf_ks,
2268 print_result(D_CBC_BF, testnum, count, d);
2272 #ifndef OPENSSL_NO_CAST
2273 if (doit[D_CBC_CAST]) {
2274 if (async_jobs > 0) {
2275 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2277 doit[D_CBC_CAST] = 0;
2279 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2280 print_message(names[D_CBC_CAST], c[D_CBC_CAST][testnum],
2283 for (count = 0, run = 1; COND(c[D_CBC_CAST][testnum]); count++)
2284 CAST_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2285 (size_t)lengths[testnum], &cast_ks,
2288 print_result(D_CBC_CAST, testnum, count, d);
2294 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
2295 if (multiblock && evp_cipher) {
2297 (EVP_CIPHER_flags(evp_cipher) &
2298 EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
2299 BIO_printf(bio_err, "%s is not multi-block capable\n",
2300 OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
2303 if (async_jobs > 0) {
2304 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2307 multiblock_speed(evp_cipher);
2312 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2315 names[D_EVP] = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
2317 * -O3 -fschedule-insns messes up an optimization here!
2318 * names[D_EVP] somehow becomes NULL
2320 print_message(names[D_EVP], save_count, lengths[testnum]);
2322 for (k = 0; k < loopargs_len; k++) {
2323 loopargs[k].ctx = EVP_CIPHER_CTX_new();
2325 EVP_DecryptInit_ex(loopargs[k].ctx, evp_cipher, NULL,
2328 EVP_EncryptInit_ex(loopargs[k].ctx, evp_cipher, NULL,
2330 EVP_CIPHER_CTX_set_padding(loopargs[k].ctx, 0);
2334 count = run_benchmark(async_jobs, EVP_Update_loop, loopargs);
2336 for (k = 0; k < loopargs_len; k++) {
2337 EVP_CIPHER_CTX_free(loopargs[k].ctx);
2341 names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
2342 print_message(names[D_EVP], save_count, lengths[testnum]);
2344 count = run_benchmark(async_jobs, EVP_Digest_loop, loopargs);
2347 print_result(D_EVP, testnum, count, d);
2351 for (i = 0; i < loopargs_len; i++)
2352 RAND_bytes(loopargs[i].buf, 36);
2354 #ifndef OPENSSL_NO_RSA
2355 for (testnum = 0; testnum < RSA_NUM; testnum++) {
2357 if (!rsa_doit[testnum])
2359 for (i = 0; i < loopargs_len; i++) {
2360 st = RSA_sign(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2361 &loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2367 "RSA sign failure. No RSA sign will be done.\n");
2368 ERR_print_errors(bio_err);
2371 pkey_print_message("private", "rsa",
2372 rsa_c[testnum][0], rsa_bits[testnum],
2374 /* RSA_blinding_on(rsa_key[testnum],NULL); */
2376 count = run_benchmark(async_jobs, RSA_sign_loop, loopargs);
2379 mr ? "+R1:%ld:%d:%.2f\n"
2380 : "%ld %d bit private RSA's in %.2fs\n",
2381 count, rsa_bits[testnum], d);
2382 rsa_results[testnum][0] = d / (double)count;
2386 for (i = 0; i < loopargs_len; i++) {
2387 st = RSA_verify(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2388 loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2394 "RSA verify failure. No RSA verify will be done.\n");
2395 ERR_print_errors(bio_err);
2396 rsa_doit[testnum] = 0;
2398 pkey_print_message("public", "rsa",
2399 rsa_c[testnum][1], rsa_bits[testnum],
2402 count = run_benchmark(async_jobs, RSA_verify_loop, loopargs);
2405 mr ? "+R2:%ld:%d:%.2f\n"
2406 : "%ld %d bit public RSA's in %.2fs\n",
2407 count, rsa_bits[testnum], d);
2408 rsa_results[testnum][1] = d / (double)count;
2411 if (rsa_count <= 1) {
2412 /* if longer than 10s, don't do any more */
2413 for (testnum++; testnum < RSA_NUM; testnum++)
2414 rsa_doit[testnum] = 0;
2417 #endif /* OPENSSL_NO_RSA */
2419 for (i = 0; i < loopargs_len; i++)
2420 RAND_bytes(loopargs[i].buf, 36);
2422 #ifndef OPENSSL_NO_DSA
2423 if (RAND_status() != 1) {
2424 RAND_seed(rnd_seed, sizeof rnd_seed);
2426 for (testnum = 0; testnum < DSA_NUM; testnum++) {
2428 if (!dsa_doit[testnum])
2431 /* DSA_generate_key(dsa_key[testnum]); */
2432 /* DSA_sign_setup(dsa_key[testnum],NULL); */
2433 for (i = 0; i < loopargs_len; i++) {
2434 st = DSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2435 &loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2441 "DSA sign failure. No DSA sign will be done.\n");
2442 ERR_print_errors(bio_err);
2445 pkey_print_message("sign", "dsa",
2446 dsa_c[testnum][0], dsa_bits[testnum],
2449 count = run_benchmark(async_jobs, DSA_sign_loop, loopargs);
2452 mr ? "+R3:%ld:%d:%.2f\n"
2453 : "%ld %d bit DSA signs in %.2fs\n",
2454 count, dsa_bits[testnum], d);
2455 dsa_results[testnum][0] = d / (double)count;
2459 for (i = 0; i < loopargs_len; i++) {
2460 st = DSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2461 loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2467 "DSA verify failure. No DSA verify will be done.\n");
2468 ERR_print_errors(bio_err);
2469 dsa_doit[testnum] = 0;
2471 pkey_print_message("verify", "dsa",
2472 dsa_c[testnum][1], dsa_bits[testnum],
2475 count = run_benchmark(async_jobs, DSA_verify_loop, loopargs);
2478 mr ? "+R4:%ld:%d:%.2f\n"
2479 : "%ld %d bit DSA verify in %.2fs\n",
2480 count, dsa_bits[testnum], d);
2481 dsa_results[testnum][1] = d / (double)count;
2484 if (rsa_count <= 1) {
2485 /* if longer than 10s, don't do any more */
2486 for (testnum++; testnum < DSA_NUM; testnum++)
2487 dsa_doit[testnum] = 0;
2490 #endif /* OPENSSL_NO_DSA */
2492 #ifndef OPENSSL_NO_EC
2493 if (RAND_status() != 1) {
2494 RAND_seed(rnd_seed, sizeof rnd_seed);
2496 for (testnum = 0; testnum < EC_NUM; testnum++) {
2499 if (!ecdsa_doit[testnum])
2500 continue; /* Ignore Curve */
2501 for (i = 0; i < loopargs_len; i++) {
2502 loopargs[i].ecdsa[testnum] =
2503 EC_KEY_new_by_curve_name(test_curves[testnum]);
2504 if (loopargs[i].ecdsa[testnum] == NULL) {
2510 BIO_printf(bio_err, "ECDSA failure.\n");
2511 ERR_print_errors(bio_err);
2514 for (i = 0; i < loopargs_len; i++) {
2515 EC_KEY_precompute_mult(loopargs[i].ecdsa[testnum], NULL);
2516 /* Perform ECDSA signature test */
2517 EC_KEY_generate_key(loopargs[i].ecdsa[testnum]);
2518 st = ECDSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2519 &loopargs[i].siglen,
2520 loopargs[i].ecdsa[testnum]);
2526 "ECDSA sign failure. No ECDSA sign will be done.\n");
2527 ERR_print_errors(bio_err);
2530 pkey_print_message("sign", "ecdsa",
2531 ecdsa_c[testnum][0],
2532 test_curves_bits[testnum], ECDSA_SECONDS);
2534 count = run_benchmark(async_jobs, ECDSA_sign_loop, loopargs);
2538 mr ? "+R5:%ld:%d:%.2f\n" :
2539 "%ld %d bit ECDSA signs in %.2fs \n",
2540 count, test_curves_bits[testnum], d);
2541 ecdsa_results[testnum][0] = d / (double)count;
2545 /* Perform ECDSA verification test */
2546 for (i = 0; i < loopargs_len; i++) {
2547 st = ECDSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2549 loopargs[i].ecdsa[testnum]);
2555 "ECDSA verify failure. No ECDSA verify will be done.\n");
2556 ERR_print_errors(bio_err);
2557 ecdsa_doit[testnum] = 0;
2559 pkey_print_message("verify", "ecdsa",
2560 ecdsa_c[testnum][1],
2561 test_curves_bits[testnum], ECDSA_SECONDS);
2563 count = run_benchmark(async_jobs, ECDSA_verify_loop, loopargs);
2566 mr ? "+R6:%ld:%d:%.2f\n"
2567 : "%ld %d bit ECDSA verify in %.2fs\n",
2568 count, test_curves_bits[testnum], d);
2569 ecdsa_results[testnum][1] = d / (double)count;
2572 if (rsa_count <= 1) {
2573 /* if longer than 10s, don't do any more */
2574 for (testnum++; testnum < EC_NUM; testnum++)
2575 ecdsa_doit[testnum] = 0;
2580 if (RAND_status() != 1) {
2581 RAND_seed(rnd_seed, sizeof rnd_seed);
2583 for (testnum = 0; testnum < EC_NUM; testnum++) {
2584 int ecdh_checks = 1;
2586 if (!ecdh_doit[testnum])
2589 for (i = 0; i < loopargs_len; i++) {
2590 EVP_PKEY_CTX *kctx = NULL, *ctx = NULL;
2591 EVP_PKEY *key_A = NULL, *key_B = NULL;
2594 if (testnum == R_EC_X25519) {
2595 kctx = EVP_PKEY_CTX_new_id(test_curves[testnum], NULL); /* keygen ctx from NID */
2597 EVP_PKEY_CTX *pctx = NULL;
2598 EVP_PKEY *params = NULL;
2600 if ( /* Create the context for parameter generation */
2601 !(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL)) ||
2602 /* Initialise the parameter generation */
2603 !EVP_PKEY_paramgen_init(pctx) ||
2604 /* Set the curve by NID */
2605 !EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx,
2608 /* Create the parameter object params */
2609 !EVP_PKEY_paramgen(pctx, ¶ms) || 0) {
2611 BIO_printf(bio_err, "ECDH init failure.\n");
2612 ERR_print_errors(bio_err);
2616 /* Create the context for the key generation */
2617 kctx = EVP_PKEY_CTX_new(params, NULL);
2619 EVP_PKEY_free(params);
2621 EVP_PKEY_CTX_free(pctx);
2624 if (!kctx || /* keygen ctx is not null */
2625 !EVP_PKEY_keygen_init(kctx) || /* init keygen ctx */
2628 BIO_printf(bio_err, "ECDH keygen failure.\n");
2629 ERR_print_errors(bio_err);
2634 if (!EVP_PKEY_keygen(kctx, &key_A) || /* generate secret key A */
2635 !EVP_PKEY_keygen(kctx, &key_B) || /* generate secret key B */
2636 !(ctx = EVP_PKEY_CTX_new(key_A, NULL)) || /* derivation ctx from skeyA */
2637 !EVP_PKEY_derive_init(ctx) || /* init derivation ctx */
2638 !EVP_PKEY_derive_set_peer(ctx, key_B) || /* set peer pubkey in ctx */
2639 !EVP_PKEY_derive(ctx, NULL, &outlen) || /* determine max length */
2640 outlen > MAX_ECDH_SIZE || /* avoid buffer overflow */
2643 BIO_printf(bio_err, "ECDH key generation failure.\n");
2644 ERR_print_errors(bio_err);
2649 loopargs[i].ecdh_ctx[testnum] = ctx;
2650 loopargs[i].outlen[testnum] = outlen;
2652 EVP_PKEY_CTX_free(kctx);
2655 if (ecdh_checks != 0) {
2656 pkey_print_message("", "ecdh",
2658 test_curves_bits[testnum], ECDH_SECONDS);
2661 run_benchmark(async_jobs, ECDH_EVP_derive_key_loop, loopargs);
2664 mr ? "+R7:%ld:%d:%.2f\n" :
2665 "%ld %d-bit ECDH ops in %.2fs\n", count,
2666 test_curves_bits[testnum], d);
2667 ecdh_results[testnum][0] = d / (double)count;
2671 if (rsa_count <= 1) {
2672 /* if longer than 10s, don't do any more */
2673 for (testnum++; testnum < EC_NUM; testnum++)
2674 ecdh_doit[testnum] = 0;
2677 #endif /* OPENSSL_NO_EC */
2682 printf("%s\n", OpenSSL_version(OPENSSL_VERSION));
2683 printf("%s\n", OpenSSL_version(OPENSSL_BUILT_ON));
2685 printf("%s ", BN_options());
2686 #ifndef OPENSSL_NO_MD2
2687 printf("%s ", MD2_options());
2689 #ifndef OPENSSL_NO_RC4
2690 printf("%s ", RC4_options());
2692 #ifndef OPENSSL_NO_DES
2693 printf("%s ", DES_options());
2695 printf("%s ", AES_options());
2696 #ifndef OPENSSL_NO_IDEA
2697 printf("%s ", IDEA_options());
2699 #ifndef OPENSSL_NO_BF
2700 printf("%s ", BF_options());
2702 printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
2710 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2713 for (testnum = 0; testnum < SIZE_NUM; testnum++)
2714 printf(mr ? ":%d" : "%7d bytes", lengths[testnum]);
2718 for (k = 0; k < ALGOR_NUM; k++) {
2722 printf("+F:%d:%s", k, names[k]);
2724 printf("%-13s", names[k]);
2725 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2726 if (results[k][testnum] > 10000 && !mr)
2727 printf(" %11.2fk", results[k][testnum] / 1e3);
2729 printf(mr ? ":%.2f" : " %11.2f ", results[k][testnum]);
2733 #ifndef OPENSSL_NO_RSA
2735 for (k = 0; k < RSA_NUM; k++) {
2738 if (testnum && !mr) {
2739 printf("%18ssign verify sign/s verify/s\n", " ");
2743 printf("+F2:%u:%u:%f:%f\n",
2744 k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2746 printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2747 rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2748 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2751 #ifndef OPENSSL_NO_DSA
2753 for (k = 0; k < DSA_NUM; k++) {
2756 if (testnum && !mr) {
2757 printf("%18ssign verify sign/s verify/s\n", " ");
2761 printf("+F3:%u:%u:%f:%f\n",
2762 k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2764 printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2765 dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2766 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2769 #ifndef OPENSSL_NO_EC
2771 for (k = 0; k < EC_NUM; k++) {
2774 if (testnum && !mr) {
2775 printf("%30ssign verify sign/s verify/s\n", " ");
2780 printf("+F4:%u:%u:%f:%f\n",
2781 k, test_curves_bits[k],
2782 ecdsa_results[k][0], ecdsa_results[k][1]);
2784 printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2785 test_curves_bits[k],
2786 test_curves_names[k],
2787 ecdsa_results[k][0], ecdsa_results[k][1],
2788 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2792 for (k = 0; k < EC_NUM; k++) {
2795 if (testnum && !mr) {
2796 printf("%30sop op/s\n", " ");
2800 printf("+F5:%u:%u:%f:%f\n",
2801 k, test_curves_bits[k],
2802 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2805 printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2806 test_curves_bits[k],
2807 test_curves_names[k],
2808 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2815 ERR_print_errors(bio_err);
2816 for (i = 0; i < loopargs_len; i++) {
2817 OPENSSL_free(loopargs[i].buf_malloc);
2818 OPENSSL_free(loopargs[i].buf2_malloc);
2820 #ifndef OPENSSL_NO_RSA
2821 for (k = 0; k < RSA_NUM; k++)
2822 RSA_free(loopargs[i].rsa_key[k]);
2824 #ifndef OPENSSL_NO_DSA
2825 for (k = 0; k < DSA_NUM; k++)
2826 DSA_free(loopargs[i].dsa_key[k]);
2828 #ifndef OPENSSL_NO_EC
2829 for (k = 0; k < EC_NUM; k++) {
2830 EC_KEY_free(loopargs[i].ecdsa[k]);
2831 EVP_PKEY_CTX_free(loopargs[i].ecdh_ctx[k]);
2833 OPENSSL_free(loopargs[i].secret_a);
2834 OPENSSL_free(loopargs[i].secret_b);
2838 if (async_jobs > 0) {
2839 for (i = 0; i < loopargs_len; i++)
2840 ASYNC_WAIT_CTX_free(loopargs[i].wait_ctx);
2844 ASYNC_cleanup_thread();
2846 OPENSSL_free(loopargs);
2851 static void print_message(const char *s, long num, int length)
2855 mr ? "+DT:%s:%d:%d\n"
2856 : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2857 (void)BIO_flush(bio_err);
2861 mr ? "+DN:%s:%ld:%d\n"
2862 : "Doing %s %ld times on %d size blocks: ", s, num, length);
2863 (void)BIO_flush(bio_err);
2867 static void pkey_print_message(const char *str, const char *str2, long num,
2872 mr ? "+DTP:%d:%s:%s:%d\n"
2873 : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2874 (void)BIO_flush(bio_err);
2878 mr ? "+DNP:%ld:%d:%s:%s\n"
2879 : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2880 (void)BIO_flush(bio_err);
2884 static void print_result(int alg, int run_no, int count, double time_used)
2887 BIO_puts(bio_err, "EVP error!\n");
2891 mr ? "+R:%d:%s:%f\n"
2892 : "%d %s's in %.2fs\n", count, names[alg], time_used);
2893 results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2897 static char *sstrsep(char **string, const char *delim)
2900 char *token = *string;
2905 memset(isdelim, 0, sizeof isdelim);
2909 isdelim[(unsigned char)(*delim)] = 1;
2913 while (!isdelim[(unsigned char)(**string)]) {
2925 static int do_multi(int multi)
2930 static char sep[] = ":";
2932 fds = malloc(sizeof(*fds) * multi);
2933 for (n = 0; n < multi; ++n) {
2934 if (pipe(fd) == -1) {
2935 BIO_printf(bio_err, "pipe failure\n");
2939 (void)BIO_flush(bio_err);
2946 if (dup(fd[1]) == -1) {
2947 BIO_printf(bio_err, "dup failed\n");
2956 printf("Forked child %d\n", n);
2959 /* for now, assume the pipe is long enough to take all the output */
2960 for (n = 0; n < multi; ++n) {
2965 f = fdopen(fds[n], "r");
2966 while (fgets(buf, sizeof buf, f)) {
2967 p = strchr(buf, '\n');
2970 if (buf[0] != '+') {
2972 "Don't understand line '%s' from child %d\n", buf,
2976 printf("Got: %s from %d\n", buf, n);
2977 if (strncmp(buf, "+F:", 3) == 0) {
2982 alg = atoi(sstrsep(&p, sep));
2984 for (j = 0; j < SIZE_NUM; ++j)
2985 results[alg][j] += atof(sstrsep(&p, sep));
2986 } else if (strncmp(buf, "+F2:", 4) == 0) {
2991 k = atoi(sstrsep(&p, sep));
2994 d = atof(sstrsep(&p, sep));
2996 rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
2998 rsa_results[k][0] = d;
3000 d = atof(sstrsep(&p, sep));
3002 rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
3004 rsa_results[k][1] = d;
3006 # ifndef OPENSSL_NO_DSA
3007 else if (strncmp(buf, "+F3:", 4) == 0) {
3012 k = atoi(sstrsep(&p, sep));
3015 d = atof(sstrsep(&p, sep));
3017 dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
3019 dsa_results[k][0] = d;
3021 d = atof(sstrsep(&p, sep));
3023 dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
3025 dsa_results[k][1] = d;
3028 # ifndef OPENSSL_NO_EC
3029 else if (strncmp(buf, "+F4:", 4) == 0) {
3034 k = atoi(sstrsep(&p, sep));
3037 d = atof(sstrsep(&p, sep));
3039 ecdsa_results[k][0] = 1 / (1 / ecdsa_results[k][0] + 1 / d);
3041 ecdsa_results[k][0] = d;
3043 d = atof(sstrsep(&p, sep));
3045 ecdsa_results[k][1] = 1 / (1 / ecdsa_results[k][1] + 1 / d);
3047 ecdsa_results[k][1] = d;
3048 } else if (strncmp(buf, "+F5:", 4) == 0) {
3053 k = atoi(sstrsep(&p, sep));
3056 d = atof(sstrsep(&p, sep));
3058 ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
3060 ecdh_results[k][0] = d;
3065 else if (strncmp(buf, "+H:", 3) == 0) {
3068 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf,
3079 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
3081 static int mblengths[] =
3082 { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
3083 int j, count, num = OSSL_NELEM(mblengths);
3084 const char *alg_name;
3085 unsigned char *inp, *out, no_key[32], no_iv[16];
3086 EVP_CIPHER_CTX *ctx;
3089 inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
3090 out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
3091 ctx = EVP_CIPHER_CTX_new();
3092 EVP_EncryptInit_ex(ctx, evp_cipher, NULL, no_key, no_iv);
3093 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key), no_key);
3094 alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
3096 for (j = 0; j < num; j++) {
3097 print_message(alg_name, 0, mblengths[j]);
3099 for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
3100 unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
3101 EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
3102 size_t len = mblengths[j];
3105 memset(aad, 0, 8); /* avoid uninitialized values */
3106 aad[8] = 23; /* SSL3_RT_APPLICATION_DATA */
3107 aad[9] = 3; /* version */
3109 aad[11] = 0; /* length */
3111 mb_param.out = NULL;
3114 mb_param.interleave = 8;
3116 packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
3117 sizeof(mb_param), &mb_param);
3123 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
3124 sizeof(mb_param), &mb_param);
3128 RAND_bytes(out, 16);
3132 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
3133 EVP_AEAD_TLS1_AAD_LEN, aad);
3134 EVP_Cipher(ctx, out, inp, len + pad);
3138 BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
3139 : "%d %s's in %.2fs\n", count, "evp", d);
3140 results[D_EVP][j] = ((double)count) / d * mblengths[j];
3144 fprintf(stdout, "+H");
3145 for (j = 0; j < num; j++)
3146 fprintf(stdout, ":%d", mblengths[j]);
3147 fprintf(stdout, "\n");
3148 fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
3149 for (j = 0; j < num; j++)
3150 fprintf(stdout, ":%.2f", results[D_EVP][j]);
3151 fprintf(stdout, "\n");
3154 "The 'numbers' are in 1000s of bytes per second processed.\n");
3155 fprintf(stdout, "type ");
3156 for (j = 0; j < num; j++)
3157 fprintf(stdout, "%7d bytes", mblengths[j]);
3158 fprintf(stdout, "\n");
3159 fprintf(stdout, "%-24s", alg_name);
3161 for (j = 0; j < num; j++) {
3162 if (results[D_EVP][j] > 10000)
3163 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
3165 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
3167 fprintf(stdout, "\n");
3172 EVP_CIPHER_CTX_free(ctx);