2 * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.
3 * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
5 * Licensed under the OpenSSL license (the "License"). You may not use
6 * this file except in compliance with the License. You can obtain a copy
7 * in the file LICENSE in the source distribution or at
8 * https://www.openssl.org/source/license.html
13 #define RSA_SECONDS 10
14 #define DSA_SECONDS 10
15 #define ECDSA_SECONDS 10
16 #define ECDH_SECONDS 10
24 #include <openssl/crypto.h>
25 #include <openssl/rand.h>
26 #include <openssl/err.h>
27 #include <openssl/evp.h>
28 #include <openssl/objects.h>
29 #include <openssl/async.h>
30 #if !defined(OPENSSL_SYS_MSDOS)
31 # include OPENSSL_UNISTD
38 #include <openssl/bn.h>
39 #ifndef OPENSSL_NO_DES
40 # include <openssl/des.h>
42 #include <openssl/aes.h>
43 #ifndef OPENSSL_NO_CAMELLIA
44 # include <openssl/camellia.h>
46 #ifndef OPENSSL_NO_MD2
47 # include <openssl/md2.h>
49 #ifndef OPENSSL_NO_MDC2
50 # include <openssl/mdc2.h>
52 #ifndef OPENSSL_NO_MD4
53 # include <openssl/md4.h>
55 #ifndef OPENSSL_NO_MD5
56 # include <openssl/md5.h>
58 #include <openssl/hmac.h>
59 #include <openssl/sha.h>
60 #ifndef OPENSSL_NO_RMD160
61 # include <openssl/ripemd.h>
63 #ifndef OPENSSL_NO_WHIRLPOOL
64 # include <openssl/whrlpool.h>
66 #ifndef OPENSSL_NO_RC4
67 # include <openssl/rc4.h>
69 #ifndef OPENSSL_NO_RC5
70 # include <openssl/rc5.h>
72 #ifndef OPENSSL_NO_RC2
73 # include <openssl/rc2.h>
75 #ifndef OPENSSL_NO_IDEA
76 # include <openssl/idea.h>
78 #ifndef OPENSSL_NO_SEED
79 # include <openssl/seed.h>
82 # include <openssl/blowfish.h>
84 #ifndef OPENSSL_NO_CAST
85 # include <openssl/cast.h>
87 #ifndef OPENSSL_NO_RSA
88 # include <openssl/rsa.h>
89 # include "./testrsa.h"
91 #include <openssl/x509.h>
92 #ifndef OPENSSL_NO_DSA
93 # include <openssl/dsa.h>
94 # include "./testdsa.h"
97 # include <openssl/ec.h>
99 #include <openssl/modes.h>
102 # if defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_WINDOWS)
115 #define MAX_MISALIGNMENT 63
122 #define MAX_ECDH_SIZE 256
125 typedef struct openssl_speed_sec_st {
131 } openssl_speed_sec_t;
133 static volatile int run = 0;
136 static int usertime = 1;
138 typedef struct loopargs_st {
139 ASYNC_JOB *inprogress_job;
140 ASYNC_WAIT_CTX *wait_ctx;
143 unsigned char *buf_malloc;
144 unsigned char *buf2_malloc;
147 #ifndef OPENSSL_NO_RSA
148 RSA *rsa_key[RSA_NUM];
150 #ifndef OPENSSL_NO_DSA
151 DSA *dsa_key[DSA_NUM];
153 #ifndef OPENSSL_NO_EC
154 EC_KEY *ecdsa[EC_NUM];
155 EVP_PKEY_CTX *ecdh_ctx[EC_NUM];
156 unsigned char *secret_a;
157 unsigned char *secret_b;
158 size_t outlen[EC_NUM];
162 GCM128_CONTEXT *gcm_ctx;
165 #ifndef OPENSSL_NO_MD2
166 static int EVP_Digest_MD2_loop(void *args);
169 #ifndef OPENSSL_NO_MDC2
170 static int EVP_Digest_MDC2_loop(void *args);
172 #ifndef OPENSSL_NO_MD4
173 static int EVP_Digest_MD4_loop(void *args);
175 #ifndef OPENSSL_NO_MD5
176 static int MD5_loop(void *args);
177 static int HMAC_loop(void *args);
179 static int SHA1_loop(void *args);
180 static int SHA256_loop(void *args);
181 static int SHA512_loop(void *args);
182 #ifndef OPENSSL_NO_WHIRLPOOL
183 static int WHIRLPOOL_loop(void *args);
185 #ifndef OPENSSL_NO_RMD160
186 static int EVP_Digest_RMD160_loop(void *args);
188 #ifndef OPENSSL_NO_RC4
189 static int RC4_loop(void *args);
191 #ifndef OPENSSL_NO_DES
192 static int DES_ncbc_encrypt_loop(void *args);
193 static int DES_ede3_cbc_encrypt_loop(void *args);
195 static int AES_cbc_128_encrypt_loop(void *args);
196 static int AES_cbc_192_encrypt_loop(void *args);
197 static int AES_ige_128_encrypt_loop(void *args);
198 static int AES_cbc_256_encrypt_loop(void *args);
199 static int AES_ige_192_encrypt_loop(void *args);
200 static int AES_ige_256_encrypt_loop(void *args);
201 static int CRYPTO_gcm128_aad_loop(void *args);
202 static int RAND_bytes_loop(void *args);
203 static int EVP_Update_loop(void *args);
204 static int EVP_Update_loop_ccm(void *args);
205 static int EVP_Digest_loop(void *args);
206 #ifndef OPENSSL_NO_RSA
207 static int RSA_sign_loop(void *args);
208 static int RSA_verify_loop(void *args);
210 #ifndef OPENSSL_NO_DSA
211 static int DSA_sign_loop(void *args);
212 static int DSA_verify_loop(void *args);
214 #ifndef OPENSSL_NO_EC
215 static int ECDSA_sign_loop(void *args);
216 static int ECDSA_verify_loop(void *args);
218 static int run_benchmark(int async_jobs, int (*loop_function) (void *),
219 loopargs_t * loopargs);
221 static double Time_F(int s);
222 static void print_message(const char *s, long num, int length, int tm);
223 static void pkey_print_message(const char *str, const char *str2,
224 long num, int bits, int sec);
225 static void print_result(int alg, int run_no, int count, double time_used);
227 static int do_multi(int multi, int size_num);
230 static const int lengths_list[] = {
231 16, 64, 256, 1024, 8 * 1024, 16 * 1024
233 static int lengths_single = 0;
235 static const int *lengths = lengths_list;
237 static const char *names[ALGOR_NUM] = {
238 "md2", "mdc2", "md4", "md5", "hmac(md5)", "sha1", "rmd160", "rc4",
239 "des cbc", "des ede3", "idea cbc", "seed cbc",
240 "rc2 cbc", "rc5-32/12 cbc", "blowfish cbc", "cast cbc",
241 "aes-128 cbc", "aes-192 cbc", "aes-256 cbc",
242 "camellia-128 cbc", "camellia-192 cbc", "camellia-256 cbc",
243 "evp", "sha256", "sha512", "whirlpool",
244 "aes-128 ige", "aes-192 ige", "aes-256 ige", "ghash",
248 static double results[ALGOR_NUM][OSSL_NELEM(lengths_list)];
250 #ifndef OPENSSL_NO_RSA
251 static double rsa_results[RSA_NUM][2];
253 #ifndef OPENSSL_NO_DSA
254 static double dsa_results[DSA_NUM][2];
256 #ifndef OPENSSL_NO_EC
257 static double ecdsa_results[EC_NUM][2];
258 static double ecdh_results[EC_NUM][1];
262 # if defined(__STDC__) || defined(sgi) || defined(_AIX)
263 # define SIGRETTYPE void
265 # define SIGRETTYPE int
268 static SIGRETTYPE sig_done(int sig);
269 static SIGRETTYPE sig_done(int sig)
271 signal(SIGALRM, sig_done);
281 # if !defined(SIGALRM)
284 static unsigned int lapse;
285 static volatile unsigned int schlock;
286 static void alarm_win32(unsigned int secs)
291 # define alarm alarm_win32
293 static DWORD WINAPI sleepy(VOID * arg)
301 static double Time_F(int s)
308 thr = CreateThread(NULL, 4096, sleepy, NULL, 0, NULL);
310 DWORD err = GetLastError();
311 BIO_printf(bio_err, "unable to CreateThread (%lu)", err);
315 Sleep(0); /* scheduler spinlock */
316 ret = app_tminterval(s, usertime);
318 ret = app_tminterval(s, usertime);
320 TerminateThread(thr, 0);
328 static double Time_F(int s)
330 double ret = app_tminterval(s, usertime);
337 static void multiblock_speed(const EVP_CIPHER *evp_cipher,
338 const openssl_speed_sec_t *seconds);
340 static int found(const char *name, const OPT_PAIR *pairs, int *result)
342 for (; pairs->name; pairs++)
343 if (strcmp(name, pairs->name) == 0) {
344 *result = pairs->retval;
350 typedef enum OPTION_choice {
351 OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
352 OPT_ELAPSED, OPT_EVP, OPT_DECRYPT, OPT_ENGINE, OPT_MULTI,
353 OPT_MR, OPT_MB, OPT_MISALIGN, OPT_ASYNCJOBS, OPT_R_ENUM,
354 OPT_PRIMES, OPT_SECONDS, OPT_BYTES
357 const OPTIONS speed_options[] = {
358 {OPT_HELP_STR, 1, '-', "Usage: %s [options] ciphers...\n"},
359 {OPT_HELP_STR, 1, '-', "Valid options are:\n"},
360 {"help", OPT_HELP, '-', "Display this summary"},
361 {"evp", OPT_EVP, 's', "Use specified EVP cipher"},
362 {"decrypt", OPT_DECRYPT, '-',
363 "Time decryption instead of encryption (only EVP)"},
364 {"mr", OPT_MR, '-', "Produce machine readable output"},
366 "Enable (tls1.1) multi-block mode on evp_cipher requested with -evp"},
367 {"misalign", OPT_MISALIGN, 'n', "Amount to mis-align buffers"},
368 {"elapsed", OPT_ELAPSED, '-',
369 "Measure time in real time instead of CPU user time"},
371 {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"},
373 #ifndef OPENSSL_NO_ASYNC
374 {"async_jobs", OPT_ASYNCJOBS, 'p',
375 "Enable async mode and start pnum jobs"},
378 #ifndef OPENSSL_NO_ENGINE
379 {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
381 {"primes", OPT_PRIMES, 'p', "Specify number of primes (for RSA only)"},
382 {"seconds", OPT_SECONDS, 'p',
383 "Run benchmarks for pnum seconds"},
384 {"bytes", OPT_BYTES, 'p',
385 "Run cipher, digest and rand benchmarks on pnum bytes"},
399 #define D_CBC_IDEA 10
400 #define D_CBC_SEED 11
404 #define D_CBC_CAST 15
405 #define D_CBC_128_AES 16
406 #define D_CBC_192_AES 17
407 #define D_CBC_256_AES 18
408 #define D_CBC_128_CML 19
409 #define D_CBC_192_CML 20
410 #define D_CBC_256_CML 21
414 #define D_WHIRLPOOL 25
415 #define D_IGE_128_AES 26
416 #define D_IGE_192_AES 27
417 #define D_IGE_256_AES 28
420 static OPT_PAIR doit_choices[] = {
421 #ifndef OPENSSL_NO_MD2
424 #ifndef OPENSSL_NO_MDC2
427 #ifndef OPENSSL_NO_MD4
430 #ifndef OPENSSL_NO_MD5
435 {"sha256", D_SHA256},
436 {"sha512", D_SHA512},
437 #ifndef OPENSSL_NO_WHIRLPOOL
438 {"whirlpool", D_WHIRLPOOL},
440 #ifndef OPENSSL_NO_RMD160
441 {"ripemd", D_RMD160},
442 {"rmd160", D_RMD160},
443 {"ripemd160", D_RMD160},
445 #ifndef OPENSSL_NO_RC4
448 #ifndef OPENSSL_NO_DES
449 {"des-cbc", D_CBC_DES},
450 {"des-ede3", D_EDE3_DES},
452 {"aes-128-cbc", D_CBC_128_AES},
453 {"aes-192-cbc", D_CBC_192_AES},
454 {"aes-256-cbc", D_CBC_256_AES},
455 {"aes-128-ige", D_IGE_128_AES},
456 {"aes-192-ige", D_IGE_192_AES},
457 {"aes-256-ige", D_IGE_256_AES},
458 #ifndef OPENSSL_NO_RC2
459 {"rc2-cbc", D_CBC_RC2},
462 #ifndef OPENSSL_NO_RC5
463 {"rc5-cbc", D_CBC_RC5},
466 #ifndef OPENSSL_NO_IDEA
467 {"idea-cbc", D_CBC_IDEA},
468 {"idea", D_CBC_IDEA},
470 #ifndef OPENSSL_NO_SEED
471 {"seed-cbc", D_CBC_SEED},
472 {"seed", D_CBC_SEED},
474 #ifndef OPENSSL_NO_BF
475 {"bf-cbc", D_CBC_BF},
476 {"blowfish", D_CBC_BF},
479 #ifndef OPENSSL_NO_CAST
480 {"cast-cbc", D_CBC_CAST},
481 {"cast", D_CBC_CAST},
482 {"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
537 #ifndef OPENSSL_NO_EC
538 static OPT_PAIR ecdsa_choices[] = {
539 {"ecdsap160", R_EC_P160},
540 {"ecdsap192", R_EC_P192},
541 {"ecdsap224", R_EC_P224},
542 {"ecdsap256", R_EC_P256},
543 {"ecdsap384", R_EC_P384},
544 {"ecdsap521", R_EC_P521},
545 {"ecdsak163", R_EC_K163},
546 {"ecdsak233", R_EC_K233},
547 {"ecdsak283", R_EC_K283},
548 {"ecdsak409", R_EC_K409},
549 {"ecdsak571", R_EC_K571},
550 {"ecdsab163", R_EC_B163},
551 {"ecdsab233", R_EC_B233},
552 {"ecdsab283", R_EC_B283},
553 {"ecdsab409", R_EC_B409},
554 {"ecdsab571", R_EC_B571},
558 static OPT_PAIR ecdh_choices[] = {
559 {"ecdhp160", R_EC_P160},
560 {"ecdhp192", R_EC_P192},
561 {"ecdhp224", R_EC_P224},
562 {"ecdhp256", R_EC_P256},
563 {"ecdhp384", R_EC_P384},
564 {"ecdhp521", R_EC_P521},
565 {"ecdhk163", R_EC_K163},
566 {"ecdhk233", R_EC_K233},
567 {"ecdhk283", R_EC_K283},
568 {"ecdhk409", R_EC_K409},
569 {"ecdhk571", R_EC_K571},
570 {"ecdhb163", R_EC_B163},
571 {"ecdhb233", R_EC_B233},
572 {"ecdhb283", R_EC_B283},
573 {"ecdhb409", R_EC_B409},
574 {"ecdhb571", R_EC_B571},
575 {"ecdhx25519", R_EC_X25519},
576 {"ecdhx448", R_EC_X448},
582 # define COND(d) (count < (d))
583 # define COUNT(d) (d)
585 # define COND(unused_cond) (run && count<0x7fffffff)
586 # define COUNT(d) (count)
591 /* Nb of iterations to do per algorithm and key-size */
592 static long c[ALGOR_NUM][OSSL_NELEM(lengths_list)];
594 #ifndef OPENSSL_NO_MD2
595 static int EVP_Digest_MD2_loop(void *args)
597 loopargs_t *tempargs = *(loopargs_t **) args;
598 unsigned char *buf = tempargs->buf;
599 unsigned char md2[MD2_DIGEST_LENGTH];
602 for (count = 0; COND(c[D_MD2][testnum]); count++) {
603 if (!EVP_Digest(buf, (size_t)lengths[testnum], md2, NULL, EVP_md2(),
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];
619 for (count = 0; COND(c[D_MDC2][testnum]); count++) {
620 if (!EVP_Digest(buf, (size_t)lengths[testnum], mdc2, NULL, EVP_mdc2(),
628 #ifndef OPENSSL_NO_MD4
629 static int EVP_Digest_MD4_loop(void *args)
631 loopargs_t *tempargs = *(loopargs_t **) args;
632 unsigned char *buf = tempargs->buf;
633 unsigned char md4[MD4_DIGEST_LENGTH];
636 for (count = 0; COND(c[D_MD4][testnum]); count++) {
637 if (!EVP_Digest(buf, (size_t)lengths[testnum], md4, NULL, EVP_md4(),
645 #ifndef OPENSSL_NO_MD5
646 static int MD5_loop(void *args)
648 loopargs_t *tempargs = *(loopargs_t **) args;
649 unsigned char *buf = tempargs->buf;
650 unsigned char md5[MD5_DIGEST_LENGTH];
652 for (count = 0; COND(c[D_MD5][testnum]); count++)
653 MD5(buf, lengths[testnum], md5);
657 static int HMAC_loop(void *args)
659 loopargs_t *tempargs = *(loopargs_t **) args;
660 unsigned char *buf = tempargs->buf;
661 HMAC_CTX *hctx = tempargs->hctx;
662 unsigned char hmac[MD5_DIGEST_LENGTH];
665 for (count = 0; COND(c[D_HMAC][testnum]); count++) {
666 HMAC_Init_ex(hctx, NULL, 0, NULL, NULL);
667 HMAC_Update(hctx, buf, lengths[testnum]);
668 HMAC_Final(hctx, hmac, NULL);
674 static int SHA1_loop(void *args)
676 loopargs_t *tempargs = *(loopargs_t **) args;
677 unsigned char *buf = tempargs->buf;
678 unsigned char sha[SHA_DIGEST_LENGTH];
680 for (count = 0; COND(c[D_SHA1][testnum]); count++)
681 SHA1(buf, lengths[testnum], sha);
685 static int SHA256_loop(void *args)
687 loopargs_t *tempargs = *(loopargs_t **) args;
688 unsigned char *buf = tempargs->buf;
689 unsigned char sha256[SHA256_DIGEST_LENGTH];
691 for (count = 0; COND(c[D_SHA256][testnum]); count++)
692 SHA256(buf, lengths[testnum], sha256);
696 static int SHA512_loop(void *args)
698 loopargs_t *tempargs = *(loopargs_t **) args;
699 unsigned char *buf = tempargs->buf;
700 unsigned char sha512[SHA512_DIGEST_LENGTH];
702 for (count = 0; COND(c[D_SHA512][testnum]); count++)
703 SHA512(buf, lengths[testnum], sha512);
707 #ifndef OPENSSL_NO_WHIRLPOOL
708 static int WHIRLPOOL_loop(void *args)
710 loopargs_t *tempargs = *(loopargs_t **) args;
711 unsigned char *buf = tempargs->buf;
712 unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];
714 for (count = 0; COND(c[D_WHIRLPOOL][testnum]); count++)
715 WHIRLPOOL(buf, lengths[testnum], whirlpool);
720 #ifndef OPENSSL_NO_RMD160
721 static int EVP_Digest_RMD160_loop(void *args)
723 loopargs_t *tempargs = *(loopargs_t **) args;
724 unsigned char *buf = tempargs->buf;
725 unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
727 for (count = 0; COND(c[D_RMD160][testnum]); count++) {
728 if (!EVP_Digest(buf, (size_t)lengths[testnum], &(rmd160[0]),
729 NULL, EVP_ripemd160(), NULL))
736 #ifndef OPENSSL_NO_RC4
737 static RC4_KEY rc4_ks;
738 static int RC4_loop(void *args)
740 loopargs_t *tempargs = *(loopargs_t **) args;
741 unsigned char *buf = tempargs->buf;
743 for (count = 0; COND(c[D_RC4][testnum]); count++)
744 RC4(&rc4_ks, (size_t)lengths[testnum], buf, buf);
749 #ifndef OPENSSL_NO_DES
750 static unsigned char DES_iv[8];
751 static DES_key_schedule sch;
752 static DES_key_schedule sch2;
753 static DES_key_schedule sch3;
754 static int DES_ncbc_encrypt_loop(void *args)
756 loopargs_t *tempargs = *(loopargs_t **) args;
757 unsigned char *buf = tempargs->buf;
759 for (count = 0; COND(c[D_CBC_DES][testnum]); count++)
760 DES_ncbc_encrypt(buf, buf, lengths[testnum], &sch,
761 &DES_iv, DES_ENCRYPT);
765 static int DES_ede3_cbc_encrypt_loop(void *args)
767 loopargs_t *tempargs = *(loopargs_t **) args;
768 unsigned char *buf = tempargs->buf;
770 for (count = 0; COND(c[D_EDE3_DES][testnum]); count++)
771 DES_ede3_cbc_encrypt(buf, buf, lengths[testnum],
772 &sch, &sch2, &sch3, &DES_iv, DES_ENCRYPT);
777 #define MAX_BLOCK_SIZE 128
779 static unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
780 static AES_KEY aes_ks1, aes_ks2, aes_ks3;
781 static int AES_cbc_128_encrypt_loop(void *args)
783 loopargs_t *tempargs = *(loopargs_t **) args;
784 unsigned char *buf = tempargs->buf;
786 for (count = 0; COND(c[D_CBC_128_AES][testnum]); count++)
787 AES_cbc_encrypt(buf, buf,
788 (size_t)lengths[testnum], &aes_ks1, iv, AES_ENCRYPT);
792 static int AES_cbc_192_encrypt_loop(void *args)
794 loopargs_t *tempargs = *(loopargs_t **) args;
795 unsigned char *buf = tempargs->buf;
797 for (count = 0; COND(c[D_CBC_192_AES][testnum]); count++)
798 AES_cbc_encrypt(buf, buf,
799 (size_t)lengths[testnum], &aes_ks2, iv, AES_ENCRYPT);
803 static int AES_cbc_256_encrypt_loop(void *args)
805 loopargs_t *tempargs = *(loopargs_t **) args;
806 unsigned char *buf = tempargs->buf;
808 for (count = 0; COND(c[D_CBC_256_AES][testnum]); count++)
809 AES_cbc_encrypt(buf, buf,
810 (size_t)lengths[testnum], &aes_ks3, iv, AES_ENCRYPT);
814 static int AES_ige_128_encrypt_loop(void *args)
816 loopargs_t *tempargs = *(loopargs_t **) args;
817 unsigned char *buf = tempargs->buf;
818 unsigned char *buf2 = tempargs->buf2;
820 for (count = 0; COND(c[D_IGE_128_AES][testnum]); count++)
821 AES_ige_encrypt(buf, buf2,
822 (size_t)lengths[testnum], &aes_ks1, iv, AES_ENCRYPT);
826 static int AES_ige_192_encrypt_loop(void *args)
828 loopargs_t *tempargs = *(loopargs_t **) args;
829 unsigned char *buf = tempargs->buf;
830 unsigned char *buf2 = tempargs->buf2;
832 for (count = 0; COND(c[D_IGE_192_AES][testnum]); count++)
833 AES_ige_encrypt(buf, buf2,
834 (size_t)lengths[testnum], &aes_ks2, iv, AES_ENCRYPT);
838 static int AES_ige_256_encrypt_loop(void *args)
840 loopargs_t *tempargs = *(loopargs_t **) args;
841 unsigned char *buf = tempargs->buf;
842 unsigned char *buf2 = tempargs->buf2;
844 for (count = 0; COND(c[D_IGE_256_AES][testnum]); count++)
845 AES_ige_encrypt(buf, buf2,
846 (size_t)lengths[testnum], &aes_ks3, iv, AES_ENCRYPT);
850 static int CRYPTO_gcm128_aad_loop(void *args)
852 loopargs_t *tempargs = *(loopargs_t **) args;
853 unsigned char *buf = tempargs->buf;
854 GCM128_CONTEXT *gcm_ctx = tempargs->gcm_ctx;
856 for (count = 0; COND(c[D_GHASH][testnum]); count++)
857 CRYPTO_gcm128_aad(gcm_ctx, buf, lengths[testnum]);
861 static int RAND_bytes_loop(void *args)
863 loopargs_t *tempargs = *(loopargs_t **) args;
864 unsigned char *buf = tempargs->buf;
867 for (count = 0; COND(c[D_RAND][testnum]); count++)
868 RAND_bytes(buf, lengths[testnum]);
872 static long save_count = 0;
873 static int decrypt = 0;
874 static int EVP_Update_loop(void *args)
876 loopargs_t *tempargs = *(loopargs_t **) args;
877 unsigned char *buf = tempargs->buf;
878 EVP_CIPHER_CTX *ctx = tempargs->ctx;
881 int nb_iter = save_count * 4 * lengths[0] / lengths[testnum];
884 for (count = 0; COND(nb_iter); count++) {
885 rc = EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
887 EVP_CipherInit_ex(ctx, NULL, NULL, NULL, iv, -1);
890 for (count = 0; COND(nb_iter); count++) {
891 rc = EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
893 EVP_CipherInit_ex(ctx, NULL, NULL, NULL, iv, -1);
897 EVP_DecryptFinal_ex(ctx, buf, &outl);
899 EVP_EncryptFinal_ex(ctx, buf, &outl);
903 * CCM does not support streaming. For the purpose of performance measurement,
904 * each message is encrypted using the same (key,iv)-pair. Do not use this
905 * code in your application.
907 static int EVP_Update_loop_ccm(void *args)
909 loopargs_t *tempargs = *(loopargs_t **) args;
910 unsigned char *buf = tempargs->buf;
911 EVP_CIPHER_CTX *ctx = tempargs->ctx;
913 unsigned char tag[12];
915 int nb_iter = save_count * 4 * lengths[0] / lengths[testnum];
918 for (count = 0; COND(nb_iter); count++) {
919 EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, iv);
920 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, sizeof(tag), tag);
921 EVP_DecryptUpdate(ctx, NULL, &outl, NULL, lengths[testnum]);
922 EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
923 EVP_DecryptFinal_ex(ctx, buf, &outl);
926 for (count = 0; COND(nb_iter); count++) {
927 EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv);
928 EVP_EncryptUpdate(ctx, NULL, &outl, NULL, lengths[testnum]);
929 EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
930 EVP_EncryptFinal_ex(ctx, buf, &outl);
936 static const EVP_MD *evp_md = NULL;
937 static int EVP_Digest_loop(void *args)
939 loopargs_t *tempargs = *(loopargs_t **) args;
940 unsigned char *buf = tempargs->buf;
941 unsigned char md[EVP_MAX_MD_SIZE];
944 int nb_iter = save_count * 4 * lengths[0] / lengths[testnum];
947 for (count = 0; COND(nb_iter); count++) {
948 if (!EVP_Digest(buf, lengths[testnum], md, NULL, evp_md, NULL))
954 #ifndef OPENSSL_NO_RSA
955 static long rsa_c[RSA_NUM][2]; /* # RSA iteration test */
957 static int RSA_sign_loop(void *args)
959 loopargs_t *tempargs = *(loopargs_t **) args;
960 unsigned char *buf = tempargs->buf;
961 unsigned char *buf2 = tempargs->buf2;
962 unsigned int *rsa_num = &tempargs->siglen;
963 RSA **rsa_key = tempargs->rsa_key;
965 for (count = 0; COND(rsa_c[testnum][0]); count++) {
966 ret = RSA_sign(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
968 BIO_printf(bio_err, "RSA sign failure\n");
969 ERR_print_errors(bio_err);
977 static int RSA_verify_loop(void *args)
979 loopargs_t *tempargs = *(loopargs_t **) args;
980 unsigned char *buf = tempargs->buf;
981 unsigned char *buf2 = tempargs->buf2;
982 unsigned int rsa_num = tempargs->siglen;
983 RSA **rsa_key = tempargs->rsa_key;
985 for (count = 0; COND(rsa_c[testnum][1]); count++) {
987 RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
989 BIO_printf(bio_err, "RSA verify failure\n");
990 ERR_print_errors(bio_err);
999 #ifndef OPENSSL_NO_DSA
1000 static long dsa_c[DSA_NUM][2];
1001 static int DSA_sign_loop(void *args)
1003 loopargs_t *tempargs = *(loopargs_t **) args;
1004 unsigned char *buf = tempargs->buf;
1005 unsigned char *buf2 = tempargs->buf2;
1006 DSA **dsa_key = tempargs->dsa_key;
1007 unsigned int *siglen = &tempargs->siglen;
1009 for (count = 0; COND(dsa_c[testnum][0]); count++) {
1010 ret = DSA_sign(0, buf, 20, buf2, siglen, dsa_key[testnum]);
1012 BIO_printf(bio_err, "DSA sign failure\n");
1013 ERR_print_errors(bio_err);
1021 static int DSA_verify_loop(void *args)
1023 loopargs_t *tempargs = *(loopargs_t **) args;
1024 unsigned char *buf = tempargs->buf;
1025 unsigned char *buf2 = tempargs->buf2;
1026 DSA **dsa_key = tempargs->dsa_key;
1027 unsigned int siglen = tempargs->siglen;
1029 for (count = 0; COND(dsa_c[testnum][1]); count++) {
1030 ret = DSA_verify(0, buf, 20, buf2, siglen, dsa_key[testnum]);
1032 BIO_printf(bio_err, "DSA verify failure\n");
1033 ERR_print_errors(bio_err);
1042 #ifndef OPENSSL_NO_EC
1043 static long ecdsa_c[EC_NUM][2];
1044 static int ECDSA_sign_loop(void *args)
1046 loopargs_t *tempargs = *(loopargs_t **) args;
1047 unsigned char *buf = tempargs->buf;
1048 EC_KEY **ecdsa = tempargs->ecdsa;
1049 unsigned char *ecdsasig = tempargs->buf2;
1050 unsigned int *ecdsasiglen = &tempargs->siglen;
1052 for (count = 0; COND(ecdsa_c[testnum][0]); count++) {
1053 ret = ECDSA_sign(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[testnum]);
1055 BIO_printf(bio_err, "ECDSA sign failure\n");
1056 ERR_print_errors(bio_err);
1064 static int ECDSA_verify_loop(void *args)
1066 loopargs_t *tempargs = *(loopargs_t **) args;
1067 unsigned char *buf = tempargs->buf;
1068 EC_KEY **ecdsa = tempargs->ecdsa;
1069 unsigned char *ecdsasig = tempargs->buf2;
1070 unsigned int ecdsasiglen = tempargs->siglen;
1072 for (count = 0; COND(ecdsa_c[testnum][1]); count++) {
1073 ret = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[testnum]);
1075 BIO_printf(bio_err, "ECDSA verify failure\n");
1076 ERR_print_errors(bio_err);
1084 /* ******************************************************************** */
1085 static long ecdh_c[EC_NUM][1];
1087 static int ECDH_EVP_derive_key_loop(void *args)
1089 loopargs_t *tempargs = *(loopargs_t **) args;
1090 EVP_PKEY_CTX *ctx = tempargs->ecdh_ctx[testnum];
1091 unsigned char *derived_secret = tempargs->secret_a;
1093 size_t *outlen = &(tempargs->outlen[testnum]);
1095 for (count = 0; COND(ecdh_c[testnum][0]); count++)
1096 EVP_PKEY_derive(ctx, derived_secret, outlen);
1101 #endif /* OPENSSL_NO_EC */
1103 static int run_benchmark(int async_jobs,
1104 int (*loop_function) (void *), loopargs_t * loopargs)
1106 int job_op_count = 0;
1107 int total_op_count = 0;
1108 int num_inprogress = 0;
1109 int error = 0, i = 0, ret = 0;
1110 OSSL_ASYNC_FD job_fd = 0;
1111 size_t num_job_fds = 0;
1115 if (async_jobs == 0) {
1116 return loop_function((void *)&loopargs);
1119 for (i = 0; i < async_jobs && !error; i++) {
1120 loopargs_t *looparg_item = loopargs + i;
1122 /* Copy pointer content (looparg_t item address) into async context */
1123 ret = ASYNC_start_job(&loopargs[i].inprogress_job, loopargs[i].wait_ctx,
1124 &job_op_count, loop_function,
1125 (void *)&looparg_item, sizeof(looparg_item));
1131 if (job_op_count == -1) {
1134 total_op_count += job_op_count;
1139 BIO_printf(bio_err, "Failure in the job\n");
1140 ERR_print_errors(bio_err);
1146 while (num_inprogress > 0) {
1147 #if defined(OPENSSL_SYS_WINDOWS)
1149 #elif defined(OPENSSL_SYS_UNIX)
1150 int select_result = 0;
1151 OSSL_ASYNC_FD max_fd = 0;
1154 FD_ZERO(&waitfdset);
1156 for (i = 0; i < async_jobs && num_inprogress > 0; i++) {
1157 if (loopargs[i].inprogress_job == NULL)
1160 if (!ASYNC_WAIT_CTX_get_all_fds
1161 (loopargs[i].wait_ctx, NULL, &num_job_fds)
1162 || num_job_fds > 1) {
1163 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1164 ERR_print_errors(bio_err);
1168 ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd,
1170 FD_SET(job_fd, &waitfdset);
1171 if (job_fd > max_fd)
1175 if (max_fd >= (OSSL_ASYNC_FD)FD_SETSIZE) {
1177 "Error: max_fd (%d) must be smaller than FD_SETSIZE (%d). "
1178 "Decrease the value of async_jobs\n",
1179 max_fd, FD_SETSIZE);
1180 ERR_print_errors(bio_err);
1185 select_result = select(max_fd + 1, &waitfdset, NULL, NULL, NULL);
1186 if (select_result == -1 && errno == EINTR)
1189 if (select_result == -1) {
1190 BIO_printf(bio_err, "Failure in the select\n");
1191 ERR_print_errors(bio_err);
1196 if (select_result == 0)
1200 for (i = 0; i < async_jobs; i++) {
1201 if (loopargs[i].inprogress_job == NULL)
1204 if (!ASYNC_WAIT_CTX_get_all_fds
1205 (loopargs[i].wait_ctx, NULL, &num_job_fds)
1206 || num_job_fds > 1) {
1207 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1208 ERR_print_errors(bio_err);
1212 ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd,
1215 #if defined(OPENSSL_SYS_UNIX)
1216 if (num_job_fds == 1 && !FD_ISSET(job_fd, &waitfdset))
1218 #elif defined(OPENSSL_SYS_WINDOWS)
1219 if (num_job_fds == 1
1220 && !PeekNamedPipe(job_fd, NULL, 0, NULL, &avail, NULL)
1225 ret = ASYNC_start_job(&loopargs[i].inprogress_job,
1226 loopargs[i].wait_ctx, &job_op_count,
1227 loop_function, (void *)(loopargs + i),
1228 sizeof(loopargs_t));
1233 if (job_op_count == -1) {
1236 total_op_count += job_op_count;
1239 loopargs[i].inprogress_job = NULL;
1244 loopargs[i].inprogress_job = NULL;
1245 BIO_printf(bio_err, "Failure in the job\n");
1246 ERR_print_errors(bio_err);
1253 return error ? -1 : total_op_count;
1256 int speed_main(int argc, char **argv)
1259 int (*loopfunc)(void *args);
1260 loopargs_t *loopargs = NULL;
1262 int loopargs_len = 0;
1264 const char *engine_id = NULL;
1265 const EVP_CIPHER *evp_cipher = NULL;
1268 int multiblock = 0, pr_header = 0;
1269 int doit[ALGOR_NUM] = { 0 };
1270 int ret = 1, i, k, misalign = 0;
1272 int size_num = OSSL_NELEM(lengths_list);
1278 unsigned int async_jobs = 0;
1279 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) \
1280 || !defined(OPENSSL_NO_EC)
1283 #ifndef OPENSSL_NO_EC
1287 /* What follows are the buffers and key material. */
1288 #ifndef OPENSSL_NO_RC5
1291 #ifndef OPENSSL_NO_RC2
1294 #ifndef OPENSSL_NO_IDEA
1295 IDEA_KEY_SCHEDULE idea_ks;
1297 #ifndef OPENSSL_NO_SEED
1298 SEED_KEY_SCHEDULE seed_ks;
1300 #ifndef OPENSSL_NO_BF
1303 #ifndef OPENSSL_NO_CAST
1306 static const unsigned char key16[16] = {
1307 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1308 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1310 static const unsigned char key24[24] = {
1311 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1312 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1313 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1315 static const unsigned char key32[32] = {
1316 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1317 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1318 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1319 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1321 #ifndef OPENSSL_NO_CAMELLIA
1322 static const unsigned char ckey24[24] = {
1323 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1324 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1325 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1327 static const unsigned char ckey32[32] = {
1328 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1329 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1330 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1331 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1333 CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
1335 #ifndef OPENSSL_NO_DES
1336 static DES_cblock key = {
1337 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
1339 static DES_cblock key2 = {
1340 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1342 static DES_cblock key3 = {
1343 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1346 #ifndef OPENSSL_NO_RSA
1347 static const unsigned int rsa_bits[RSA_NUM] = {
1348 512, 1024, 2048, 3072, 4096, 7680, 15360
1350 static const unsigned char *rsa_data[RSA_NUM] = {
1351 test512, test1024, test2048, test3072, test4096, test7680, test15360
1353 static const int rsa_data_length[RSA_NUM] = {
1354 sizeof(test512), sizeof(test1024),
1355 sizeof(test2048), sizeof(test3072),
1356 sizeof(test4096), sizeof(test7680),
1359 int rsa_doit[RSA_NUM] = { 0 };
1360 int primes = RSA_DEFAULT_PRIME_NUM;
1362 #ifndef OPENSSL_NO_DSA
1363 static const unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
1364 int dsa_doit[DSA_NUM] = { 0 };
1366 #ifndef OPENSSL_NO_EC
1368 * We only test over the following curves as they are representative, To
1369 * add tests over more curves, simply add the curve NID and curve name to
1370 * the following arrays and increase the EC_NUM value accordingly.
1372 static const unsigned int test_curves[EC_NUM] = {
1374 NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
1375 NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
1377 NID_sect163k1, NID_sect233k1, NID_sect283k1,
1378 NID_sect409k1, NID_sect571k1, NID_sect163r2,
1379 NID_sect233r1, NID_sect283r1, NID_sect409r1,
1382 NID_X25519, NID_X448
1384 static const char *test_curves_names[EC_NUM] = {
1386 "secp160r1", "nistp192", "nistp224",
1387 "nistp256", "nistp384", "nistp521",
1389 "nistk163", "nistk233", "nistk283",
1390 "nistk409", "nistk571", "nistb163",
1391 "nistb233", "nistb283", "nistb409",
1396 static const int test_curves_bits[EC_NUM] = {
1405 int ecdsa_doit[EC_NUM] = { 0 };
1406 int ecdh_doit[EC_NUM] = { 0 };
1407 #endif /* ndef OPENSSL_NO_EC */
1409 openssl_speed_sec_t seconds = { SECONDS, RSA_SECONDS, DSA_SECONDS,
1410 ECDSA_SECONDS, ECDH_SECONDS };
1412 prog = opt_init(argc, argv, speed_options);
1413 while ((o = opt_next()) != OPT_EOF) {
1418 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
1421 opt_help(speed_options);
1429 evp_cipher = EVP_get_cipherbyname(opt_arg());
1430 if (evp_cipher == NULL)
1431 evp_md = EVP_get_digestbyname(opt_arg());
1432 if (evp_cipher == NULL && evp_md == NULL) {
1434 "%s: %s is an unknown cipher or digest\n",
1445 * In a forked execution, an engine might need to be
1446 * initialised by each child process, not by the parent.
1447 * So store the name here and run setup_engine() later on.
1449 engine_id = opt_arg();
1453 multi = atoi(opt_arg());
1457 #ifndef OPENSSL_NO_ASYNC
1458 async_jobs = atoi(opt_arg());
1459 if (!ASYNC_is_capable()) {
1461 "%s: async_jobs specified but async not supported\n",
1465 if (async_jobs > 99999) {
1467 "%s: too many async_jobs\n",
1474 if (!opt_int(opt_arg(), &misalign))
1476 if (misalign > MISALIGN) {
1478 "%s: Maximum offset is %d\n", prog, MISALIGN);
1487 #ifdef OPENSSL_NO_MULTIBLOCK
1489 "%s: -mb specified but multi-block support is disabled\n",
1499 if (!opt_int(opt_arg(), &primes))
1503 seconds.sym = seconds.rsa = seconds.dsa = seconds.ecdsa
1504 = seconds.ecdh = atoi(opt_arg());
1507 lengths_single = atoi(opt_arg());
1508 lengths = &lengths_single;
1513 argc = opt_num_rest();
1516 /* Remaining arguments are algorithms. */
1517 for (; *argv; argv++) {
1518 if (found(*argv, doit_choices, &i)) {
1522 #ifndef OPENSSL_NO_DES
1523 if (strcmp(*argv, "des") == 0) {
1524 doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
1528 if (strcmp(*argv, "sha") == 0) {
1529 doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
1532 #ifndef OPENSSL_NO_RSA
1533 if (strcmp(*argv, "openssl") == 0)
1535 if (strcmp(*argv, "rsa") == 0) {
1536 rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
1537 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
1538 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
1539 rsa_doit[R_RSA_15360] = 1;
1542 if (found(*argv, rsa_choices, &i)) {
1547 #ifndef OPENSSL_NO_DSA
1548 if (strcmp(*argv, "dsa") == 0) {
1549 dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
1550 dsa_doit[R_DSA_2048] = 1;
1553 if (found(*argv, dsa_choices, &i)) {
1558 if (strcmp(*argv, "aes") == 0) {
1559 doit[D_CBC_128_AES] = doit[D_CBC_192_AES] = doit[D_CBC_256_AES] = 1;
1562 #ifndef OPENSSL_NO_CAMELLIA
1563 if (strcmp(*argv, "camellia") == 0) {
1564 doit[D_CBC_128_CML] = doit[D_CBC_192_CML] = doit[D_CBC_256_CML] = 1;
1568 #ifndef OPENSSL_NO_EC
1569 if (strcmp(*argv, "ecdsa") == 0) {
1570 for (loop = 0; loop < OSSL_NELEM(ecdsa_choices); loop++)
1571 ecdsa_doit[ecdsa_choices[loop].retval] = 1;
1574 if (found(*argv, ecdsa_choices, &i)) {
1578 if (strcmp(*argv, "ecdh") == 0) {
1579 for (loop = 0; loop < OSSL_NELEM(ecdh_choices); loop++)
1580 ecdh_doit[ecdh_choices[loop].retval] = 1;
1583 if (found(*argv, ecdh_choices, &i)) {
1588 BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
1592 /* Initialize the job pool if async mode is enabled */
1593 if (async_jobs > 0) {
1594 async_init = ASYNC_init_thread(async_jobs, async_jobs);
1596 BIO_printf(bio_err, "Error creating the ASYNC job pool\n");
1601 loopargs_len = (async_jobs == 0 ? 1 : async_jobs);
1603 app_malloc(loopargs_len * sizeof(loopargs_t), "array of loopargs");
1604 memset(loopargs, 0, loopargs_len * sizeof(loopargs_t));
1606 for (i = 0; i < loopargs_len; i++) {
1607 if (async_jobs > 0) {
1608 loopargs[i].wait_ctx = ASYNC_WAIT_CTX_new();
1609 if (loopargs[i].wait_ctx == NULL) {
1610 BIO_printf(bio_err, "Error creating the ASYNC_WAIT_CTX\n");
1615 buflen = lengths[size_num - 1] + MAX_MISALIGNMENT + 1;
1616 loopargs[i].buf_malloc = app_malloc(buflen, "input buffer");
1617 loopargs[i].buf2_malloc = app_malloc(buflen, "input buffer");
1618 memset(loopargs[i].buf_malloc, 0, buflen);
1619 memset(loopargs[i].buf2_malloc, 0, buflen);
1621 /* Align the start of buffers on a 64 byte boundary */
1622 loopargs[i].buf = loopargs[i].buf_malloc + misalign;
1623 loopargs[i].buf2 = loopargs[i].buf2_malloc + misalign;
1624 #ifndef OPENSSL_NO_EC
1625 loopargs[i].secret_a = app_malloc(MAX_ECDH_SIZE, "ECDH secret a");
1626 loopargs[i].secret_b = app_malloc(MAX_ECDH_SIZE, "ECDH secret b");
1631 if (multi && do_multi(multi, size_num))
1635 /* Initialize the engine after the fork */
1636 e = setup_engine(engine_id, 0);
1638 /* No parameters; turn on everything. */
1639 if ((argc == 0) && !doit[D_EVP]) {
1640 for (i = 0; i < ALGOR_NUM; i++)
1643 #ifndef OPENSSL_NO_RSA
1644 for (i = 0; i < RSA_NUM; i++)
1647 #ifndef OPENSSL_NO_DSA
1648 for (i = 0; i < DSA_NUM; i++)
1651 #ifndef OPENSSL_NO_EC
1652 for (loop = 0; loop < OSSL_NELEM(ecdsa_choices); loop++)
1653 ecdsa_doit[ecdsa_choices[loop].retval] = 1;
1654 for (loop = 0; loop < OSSL_NELEM(ecdh_choices); loop++)
1655 ecdh_doit[ecdh_choices[loop].retval] = 1;
1658 for (i = 0; i < ALGOR_NUM; i++)
1662 if (usertime == 0 && !mr)
1664 "You have chosen to measure elapsed time "
1665 "instead of user CPU time.\n");
1667 #ifndef OPENSSL_NO_RSA
1668 for (i = 0; i < loopargs_len; i++) {
1669 if (primes > RSA_DEFAULT_PRIME_NUM) {
1670 /* for multi-prime RSA, skip this */
1673 for (k = 0; k < RSA_NUM; k++) {
1674 const unsigned char *p;
1677 loopargs[i].rsa_key[k] =
1678 d2i_RSAPrivateKey(NULL, &p, rsa_data_length[k]);
1679 if (loopargs[i].rsa_key[k] == NULL) {
1681 "internal error loading RSA key number %d\n", k);
1687 #ifndef OPENSSL_NO_DSA
1688 for (i = 0; i < loopargs_len; i++) {
1689 loopargs[i].dsa_key[0] = get_dsa(512);
1690 loopargs[i].dsa_key[1] = get_dsa(1024);
1691 loopargs[i].dsa_key[2] = get_dsa(2048);
1694 #ifndef OPENSSL_NO_DES
1695 DES_set_key_unchecked(&key, &sch);
1696 DES_set_key_unchecked(&key2, &sch2);
1697 DES_set_key_unchecked(&key3, &sch3);
1699 AES_set_encrypt_key(key16, 128, &aes_ks1);
1700 AES_set_encrypt_key(key24, 192, &aes_ks2);
1701 AES_set_encrypt_key(key32, 256, &aes_ks3);
1702 #ifndef OPENSSL_NO_CAMELLIA
1703 Camellia_set_key(key16, 128, &camellia_ks1);
1704 Camellia_set_key(ckey24, 192, &camellia_ks2);
1705 Camellia_set_key(ckey32, 256, &camellia_ks3);
1707 #ifndef OPENSSL_NO_IDEA
1708 IDEA_set_encrypt_key(key16, &idea_ks);
1710 #ifndef OPENSSL_NO_SEED
1711 SEED_set_key(key16, &seed_ks);
1713 #ifndef OPENSSL_NO_RC4
1714 RC4_set_key(&rc4_ks, 16, key16);
1716 #ifndef OPENSSL_NO_RC2
1717 RC2_set_key(&rc2_ks, 16, key16, 128);
1719 #ifndef OPENSSL_NO_RC5
1720 RC5_32_set_key(&rc5_ks, 16, key16, 12);
1722 #ifndef OPENSSL_NO_BF
1723 BF_set_key(&bf_ks, 16, key16);
1725 #ifndef OPENSSL_NO_CAST
1726 CAST_set_key(&cast_ks, 16, key16);
1729 # ifndef OPENSSL_NO_DES
1730 BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1736 for (it = count; it; it--)
1737 DES_ecb_encrypt((DES_cblock *)loopargs[0].buf,
1738 (DES_cblock *)loopargs[0].buf, &sch, DES_ENCRYPT);
1742 c[D_MD2][0] = count / 10;
1743 c[D_MDC2][0] = count / 10;
1744 c[D_MD4][0] = count;
1745 c[D_MD5][0] = count;
1746 c[D_HMAC][0] = count;
1747 c[D_SHA1][0] = count;
1748 c[D_RMD160][0] = count;
1749 c[D_RC4][0] = count * 5;
1750 c[D_CBC_DES][0] = count;
1751 c[D_EDE3_DES][0] = count / 3;
1752 c[D_CBC_IDEA][0] = count;
1753 c[D_CBC_SEED][0] = count;
1754 c[D_CBC_RC2][0] = count;
1755 c[D_CBC_RC5][0] = count;
1756 c[D_CBC_BF][0] = count;
1757 c[D_CBC_CAST][0] = count;
1758 c[D_CBC_128_AES][0] = count;
1759 c[D_CBC_192_AES][0] = count;
1760 c[D_CBC_256_AES][0] = count;
1761 c[D_CBC_128_CML][0] = count;
1762 c[D_CBC_192_CML][0] = count;
1763 c[D_CBC_256_CML][0] = count;
1764 c[D_SHA256][0] = count;
1765 c[D_SHA512][0] = count;
1766 c[D_WHIRLPOOL][0] = count;
1767 c[D_IGE_128_AES][0] = count;
1768 c[D_IGE_192_AES][0] = count;
1769 c[D_IGE_256_AES][0] = count;
1770 c[D_GHASH][0] = count;
1771 c[D_RAND][0] = count;
1773 for (i = 1; i < size_num; i++) {
1776 l0 = (long)lengths[0];
1777 l1 = (long)lengths[i];
1779 c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1780 c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1781 c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1782 c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1783 c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1784 c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1785 c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1786 c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1787 c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1788 c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1789 c[D_GHASH][i] = c[D_GHASH][0] * 4 * l0 / l1;
1790 c[D_RAND][i] = c[D_RAND][0] * 4 * l0 / l1;
1792 l0 = (long)lengths[i - 1];
1794 c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1795 c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1796 c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1797 c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1798 c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1799 c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1800 c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1801 c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1802 c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1803 c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1804 c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1805 c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1806 c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1807 c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1808 c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1809 c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1810 c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1811 c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1814 # ifndef OPENSSL_NO_RSA
1815 rsa_c[R_RSA_512][0] = count / 2000;
1816 rsa_c[R_RSA_512][1] = count / 400;
1817 for (i = 1; i < RSA_NUM; i++) {
1818 rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1819 rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1820 if (rsa_doit[i] <= 1 && rsa_c[i][0] == 0)
1823 if (rsa_c[i][0] == 0) {
1824 rsa_c[i][0] = 1; /* Set minimum iteration Nb to 1. */
1831 # ifndef OPENSSL_NO_DSA
1832 dsa_c[R_DSA_512][0] = count / 1000;
1833 dsa_c[R_DSA_512][1] = count / 1000 / 2;
1834 for (i = 1; i < DSA_NUM; i++) {
1835 dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1836 dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1837 if (dsa_doit[i] <= 1 && dsa_c[i][0] == 0)
1840 if (dsa_c[i][0] == 0) {
1841 dsa_c[i][0] = 1; /* Set minimum iteration Nb to 1. */
1848 # ifndef OPENSSL_NO_EC
1849 ecdsa_c[R_EC_P160][0] = count / 1000;
1850 ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1851 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1852 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1853 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1854 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1857 if (ecdsa_c[i][0] == 0) {
1863 ecdsa_c[R_EC_K163][0] = count / 1000;
1864 ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1865 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1866 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1867 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1868 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1871 if (ecdsa_c[i][0] == 0) {
1877 ecdsa_c[R_EC_B163][0] = count / 1000;
1878 ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1879 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1880 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1881 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1882 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1885 if (ecdsa_c[i][0] == 0) {
1892 ecdh_c[R_EC_P160][0] = count / 1000;
1893 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1894 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1895 if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1898 if (ecdh_c[i][0] == 0) {
1903 ecdh_c[R_EC_K163][0] = count / 1000;
1904 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1905 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1906 if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1909 if (ecdh_c[i][0] == 0) {
1914 ecdh_c[R_EC_B163][0] = count / 1000;
1915 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1916 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1917 if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1920 if (ecdh_c[i][0] == 0) {
1928 /* not worth fixing */
1929 # error "You cannot disable DES on systems without SIGALRM."
1930 # endif /* OPENSSL_NO_DES */
1933 signal(SIGALRM, sig_done);
1935 #endif /* SIGALRM */
1937 #ifndef OPENSSL_NO_MD2
1939 for (testnum = 0; testnum < size_num; testnum++) {
1940 print_message(names[D_MD2], c[D_MD2][testnum], lengths[testnum],
1943 count = run_benchmark(async_jobs, EVP_Digest_MD2_loop, loopargs);
1945 print_result(D_MD2, testnum, count, d);
1949 #ifndef OPENSSL_NO_MDC2
1951 for (testnum = 0; testnum < size_num; testnum++) {
1952 print_message(names[D_MDC2], c[D_MDC2][testnum], lengths[testnum],
1955 count = run_benchmark(async_jobs, EVP_Digest_MDC2_loop, loopargs);
1957 print_result(D_MDC2, testnum, count, d);
1962 #ifndef OPENSSL_NO_MD4
1964 for (testnum = 0; testnum < size_num; testnum++) {
1965 print_message(names[D_MD4], c[D_MD4][testnum], lengths[testnum],
1968 count = run_benchmark(async_jobs, EVP_Digest_MD4_loop, loopargs);
1970 print_result(D_MD4, testnum, count, d);
1975 #ifndef OPENSSL_NO_MD5
1977 for (testnum = 0; testnum < size_num; testnum++) {
1978 print_message(names[D_MD5], c[D_MD5][testnum], lengths[testnum],
1981 count = run_benchmark(async_jobs, MD5_loop, loopargs);
1983 print_result(D_MD5, testnum, count, d);
1988 static const char hmac_key[] = "This is a key...";
1989 int len = strlen(hmac_key);
1991 for (i = 0; i < loopargs_len; i++) {
1992 loopargs[i].hctx = HMAC_CTX_new();
1993 if (loopargs[i].hctx == NULL) {
1994 BIO_printf(bio_err, "HMAC malloc failure, exiting...");
1998 HMAC_Init_ex(loopargs[i].hctx, hmac_key, len, EVP_md5(), NULL);
2000 for (testnum = 0; testnum < size_num; testnum++) {
2001 print_message(names[D_HMAC], c[D_HMAC][testnum], lengths[testnum],
2004 count = run_benchmark(async_jobs, HMAC_loop, loopargs);
2006 print_result(D_HMAC, testnum, count, d);
2008 for (i = 0; i < loopargs_len; i++) {
2009 HMAC_CTX_free(loopargs[i].hctx);
2014 for (testnum = 0; testnum < size_num; testnum++) {
2015 print_message(names[D_SHA1], c[D_SHA1][testnum], lengths[testnum],
2018 count = run_benchmark(async_jobs, SHA1_loop, loopargs);
2020 print_result(D_SHA1, testnum, count, d);
2023 if (doit[D_SHA256]) {
2024 for (testnum = 0; testnum < size_num; testnum++) {
2025 print_message(names[D_SHA256], c[D_SHA256][testnum],
2026 lengths[testnum], seconds.sym);
2028 count = run_benchmark(async_jobs, SHA256_loop, loopargs);
2030 print_result(D_SHA256, testnum, count, d);
2033 if (doit[D_SHA512]) {
2034 for (testnum = 0; testnum < size_num; testnum++) {
2035 print_message(names[D_SHA512], c[D_SHA512][testnum],
2036 lengths[testnum], seconds.sym);
2038 count = run_benchmark(async_jobs, SHA512_loop, loopargs);
2040 print_result(D_SHA512, testnum, count, d);
2043 #ifndef OPENSSL_NO_WHIRLPOOL
2044 if (doit[D_WHIRLPOOL]) {
2045 for (testnum = 0; testnum < size_num; testnum++) {
2046 print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][testnum],
2047 lengths[testnum], seconds.sym);
2049 count = run_benchmark(async_jobs, WHIRLPOOL_loop, loopargs);
2051 print_result(D_WHIRLPOOL, testnum, count, d);
2056 #ifndef OPENSSL_NO_RMD160
2057 if (doit[D_RMD160]) {
2058 for (testnum = 0; testnum < size_num; testnum++) {
2059 print_message(names[D_RMD160], c[D_RMD160][testnum],
2060 lengths[testnum], seconds.sym);
2062 count = run_benchmark(async_jobs, EVP_Digest_RMD160_loop, loopargs);
2064 print_result(D_RMD160, testnum, count, d);
2068 #ifndef OPENSSL_NO_RC4
2070 for (testnum = 0; testnum < size_num; testnum++) {
2071 print_message(names[D_RC4], c[D_RC4][testnum], lengths[testnum],
2074 count = run_benchmark(async_jobs, RC4_loop, loopargs);
2076 print_result(D_RC4, testnum, count, d);
2080 #ifndef OPENSSL_NO_DES
2081 if (doit[D_CBC_DES]) {
2082 for (testnum = 0; testnum < size_num; testnum++) {
2083 print_message(names[D_CBC_DES], c[D_CBC_DES][testnum],
2084 lengths[testnum], seconds.sym);
2086 count = run_benchmark(async_jobs, DES_ncbc_encrypt_loop, loopargs);
2088 print_result(D_CBC_DES, testnum, count, d);
2092 if (doit[D_EDE3_DES]) {
2093 for (testnum = 0; testnum < size_num; testnum++) {
2094 print_message(names[D_EDE3_DES], c[D_EDE3_DES][testnum],
2095 lengths[testnum], seconds.sym);
2098 run_benchmark(async_jobs, DES_ede3_cbc_encrypt_loop, loopargs);
2100 print_result(D_EDE3_DES, testnum, count, d);
2105 if (doit[D_CBC_128_AES]) {
2106 for (testnum = 0; testnum < size_num; testnum++) {
2107 print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][testnum],
2108 lengths[testnum], seconds.sym);
2111 run_benchmark(async_jobs, AES_cbc_128_encrypt_loop, loopargs);
2113 print_result(D_CBC_128_AES, testnum, count, d);
2116 if (doit[D_CBC_192_AES]) {
2117 for (testnum = 0; testnum < size_num; testnum++) {
2118 print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][testnum],
2119 lengths[testnum], seconds.sym);
2122 run_benchmark(async_jobs, AES_cbc_192_encrypt_loop, loopargs);
2124 print_result(D_CBC_192_AES, testnum, count, d);
2127 if (doit[D_CBC_256_AES]) {
2128 for (testnum = 0; testnum < size_num; testnum++) {
2129 print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][testnum],
2130 lengths[testnum], seconds.sym);
2133 run_benchmark(async_jobs, AES_cbc_256_encrypt_loop, loopargs);
2135 print_result(D_CBC_256_AES, testnum, count, d);
2139 if (doit[D_IGE_128_AES]) {
2140 for (testnum = 0; testnum < size_num; testnum++) {
2141 print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][testnum],
2142 lengths[testnum], seconds.sym);
2145 run_benchmark(async_jobs, AES_ige_128_encrypt_loop, loopargs);
2147 print_result(D_IGE_128_AES, testnum, count, d);
2150 if (doit[D_IGE_192_AES]) {
2151 for (testnum = 0; testnum < size_num; testnum++) {
2152 print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][testnum],
2153 lengths[testnum], seconds.sym);
2156 run_benchmark(async_jobs, AES_ige_192_encrypt_loop, loopargs);
2158 print_result(D_IGE_192_AES, testnum, count, d);
2161 if (doit[D_IGE_256_AES]) {
2162 for (testnum = 0; testnum < size_num; testnum++) {
2163 print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][testnum],
2164 lengths[testnum], seconds.sym);
2167 run_benchmark(async_jobs, AES_ige_256_encrypt_loop, loopargs);
2169 print_result(D_IGE_256_AES, testnum, count, d);
2172 if (doit[D_GHASH]) {
2173 for (i = 0; i < loopargs_len; i++) {
2174 loopargs[i].gcm_ctx =
2175 CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
2176 CRYPTO_gcm128_setiv(loopargs[i].gcm_ctx,
2177 (unsigned char *)"0123456789ab", 12);
2180 for (testnum = 0; testnum < size_num; testnum++) {
2181 print_message(names[D_GHASH], c[D_GHASH][testnum],
2182 lengths[testnum], seconds.sym);
2184 count = run_benchmark(async_jobs, CRYPTO_gcm128_aad_loop, loopargs);
2186 print_result(D_GHASH, testnum, count, d);
2188 for (i = 0; i < loopargs_len; i++)
2189 CRYPTO_gcm128_release(loopargs[i].gcm_ctx);
2191 #ifndef OPENSSL_NO_CAMELLIA
2192 if (doit[D_CBC_128_CML]) {
2193 if (async_jobs > 0) {
2194 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2195 names[D_CBC_128_CML]);
2196 doit[D_CBC_128_CML] = 0;
2198 for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2199 print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][testnum],
2200 lengths[testnum], seconds.sym);
2202 for (count = 0, run = 1; COND(c[D_CBC_128_CML][testnum]); count++)
2203 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2204 (size_t)lengths[testnum], &camellia_ks1,
2205 iv, CAMELLIA_ENCRYPT);
2207 print_result(D_CBC_128_CML, testnum, count, d);
2210 if (doit[D_CBC_192_CML]) {
2211 if (async_jobs > 0) {
2212 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2213 names[D_CBC_192_CML]);
2214 doit[D_CBC_192_CML] = 0;
2216 for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2217 print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][testnum],
2218 lengths[testnum], seconds.sym);
2219 if (async_jobs > 0) {
2220 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2224 for (count = 0, run = 1; COND(c[D_CBC_192_CML][testnum]); count++)
2225 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2226 (size_t)lengths[testnum], &camellia_ks2,
2227 iv, CAMELLIA_ENCRYPT);
2229 print_result(D_CBC_192_CML, testnum, count, d);
2232 if (doit[D_CBC_256_CML]) {
2233 if (async_jobs > 0) {
2234 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2235 names[D_CBC_256_CML]);
2236 doit[D_CBC_256_CML] = 0;
2238 for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2239 print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][testnum],
2240 lengths[testnum], seconds.sym);
2242 for (count = 0, run = 1; COND(c[D_CBC_256_CML][testnum]); count++)
2243 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2244 (size_t)lengths[testnum], &camellia_ks3,
2245 iv, CAMELLIA_ENCRYPT);
2247 print_result(D_CBC_256_CML, testnum, count, d);
2251 #ifndef OPENSSL_NO_IDEA
2252 if (doit[D_CBC_IDEA]) {
2253 if (async_jobs > 0) {
2254 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2256 doit[D_CBC_IDEA] = 0;
2258 for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2259 print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][testnum],
2260 lengths[testnum], seconds.sym);
2262 for (count = 0, run = 1; COND(c[D_CBC_IDEA][testnum]); count++)
2263 IDEA_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2264 (size_t)lengths[testnum], &idea_ks,
2267 print_result(D_CBC_IDEA, testnum, count, d);
2271 #ifndef OPENSSL_NO_SEED
2272 if (doit[D_CBC_SEED]) {
2273 if (async_jobs > 0) {
2274 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2276 doit[D_CBC_SEED] = 0;
2278 for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2279 print_message(names[D_CBC_SEED], c[D_CBC_SEED][testnum],
2280 lengths[testnum], seconds.sym);
2282 for (count = 0, run = 1; COND(c[D_CBC_SEED][testnum]); count++)
2283 SEED_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2284 (size_t)lengths[testnum], &seed_ks, iv, 1);
2286 print_result(D_CBC_SEED, testnum, count, d);
2290 #ifndef OPENSSL_NO_RC2
2291 if (doit[D_CBC_RC2]) {
2292 if (async_jobs > 0) {
2293 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2295 doit[D_CBC_RC2] = 0;
2297 for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2298 print_message(names[D_CBC_RC2], c[D_CBC_RC2][testnum],
2299 lengths[testnum], seconds.sym);
2300 if (async_jobs > 0) {
2301 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2305 for (count = 0, run = 1; COND(c[D_CBC_RC2][testnum]); count++)
2306 RC2_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2307 (size_t)lengths[testnum], &rc2_ks,
2310 print_result(D_CBC_RC2, testnum, count, d);
2314 #ifndef OPENSSL_NO_RC5
2315 if (doit[D_CBC_RC5]) {
2316 if (async_jobs > 0) {
2317 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2319 doit[D_CBC_RC5] = 0;
2321 for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2322 print_message(names[D_CBC_RC5], c[D_CBC_RC5][testnum],
2323 lengths[testnum], seconds.sym);
2324 if (async_jobs > 0) {
2325 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2329 for (count = 0, run = 1; COND(c[D_CBC_RC5][testnum]); count++)
2330 RC5_32_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2331 (size_t)lengths[testnum], &rc5_ks,
2334 print_result(D_CBC_RC5, testnum, count, d);
2338 #ifndef OPENSSL_NO_BF
2339 if (doit[D_CBC_BF]) {
2340 if (async_jobs > 0) {
2341 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2345 for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2346 print_message(names[D_CBC_BF], c[D_CBC_BF][testnum],
2347 lengths[testnum], seconds.sym);
2349 for (count = 0, run = 1; COND(c[D_CBC_BF][testnum]); count++)
2350 BF_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2351 (size_t)lengths[testnum], &bf_ks,
2354 print_result(D_CBC_BF, testnum, count, d);
2358 #ifndef OPENSSL_NO_CAST
2359 if (doit[D_CBC_CAST]) {
2360 if (async_jobs > 0) {
2361 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2363 doit[D_CBC_CAST] = 0;
2365 for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2366 print_message(names[D_CBC_CAST], c[D_CBC_CAST][testnum],
2367 lengths[testnum], seconds.sym);
2369 for (count = 0, run = 1; COND(c[D_CBC_CAST][testnum]); count++)
2370 CAST_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2371 (size_t)lengths[testnum], &cast_ks,
2374 print_result(D_CBC_CAST, testnum, count, d);
2379 for (testnum = 0; testnum < size_num; testnum++) {
2380 print_message(names[D_RAND], c[D_RAND][testnum], lengths[testnum],
2383 count = run_benchmark(async_jobs, RAND_bytes_loop, loopargs);
2385 print_result(D_RAND, testnum, count, d);
2390 if (multiblock && evp_cipher) {
2392 (EVP_CIPHER_flags(evp_cipher) &
2393 EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
2394 BIO_printf(bio_err, "%s is not multi-block capable\n",
2395 OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
2398 if (async_jobs > 0) {
2399 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2402 multiblock_speed(evp_cipher, &seconds);
2406 for (testnum = 0; testnum < size_num; testnum++) {
2409 names[D_EVP] = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
2411 * -O3 -fschedule-insns messes up an optimization here!
2412 * names[D_EVP] somehow becomes NULL
2414 print_message(names[D_EVP], save_count, lengths[testnum],
2417 for (k = 0; k < loopargs_len; k++) {
2418 loopargs[k].ctx = EVP_CIPHER_CTX_new();
2419 EVP_CipherInit_ex(loopargs[k].ctx, evp_cipher, NULL, NULL,
2420 iv, decrypt ? 0 : 1);
2422 EVP_CIPHER_CTX_set_padding(loopargs[k].ctx, 0);
2424 keylen = EVP_CIPHER_CTX_key_length(loopargs[k].ctx);
2425 loopargs[k].key = app_malloc(keylen, "evp_cipher key");
2426 EVP_CIPHER_CTX_rand_key(loopargs[k].ctx, loopargs[k].key);
2427 EVP_CipherInit_ex(loopargs[k].ctx, NULL, NULL,
2428 loopargs[k].key, NULL, -1);
2429 OPENSSL_clear_free(loopargs[k].key, keylen);
2431 switch (EVP_CIPHER_mode(evp_cipher)) {
2432 case EVP_CIPH_CCM_MODE:
2433 loopfunc = EVP_Update_loop_ccm;
2436 loopfunc = EVP_Update_loop;
2440 count = run_benchmark(async_jobs, loopfunc, loopargs);
2442 for (k = 0; k < loopargs_len; k++) {
2443 EVP_CIPHER_CTX_free(loopargs[k].ctx);
2447 names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
2448 print_message(names[D_EVP], save_count, lengths[testnum],
2451 count = run_benchmark(async_jobs, EVP_Digest_loop, loopargs);
2454 print_result(D_EVP, testnum, count, d);
2458 for (i = 0; i < loopargs_len; i++)
2459 RAND_bytes(loopargs[i].buf, 36);
2461 #ifndef OPENSSL_NO_RSA
2462 for (testnum = 0; testnum < RSA_NUM; testnum++) {
2464 if (!rsa_doit[testnum])
2466 for (i = 0; i < loopargs_len; i++) {
2468 /* we haven't set keys yet, generate multi-prime RSA keys */
2469 BIGNUM *bn = BN_new();
2473 if (!BN_set_word(bn, RSA_F4)) {
2478 BIO_printf(bio_err, "Generate multi-prime RSA key for %s\n",
2479 rsa_choices[testnum].name);
2481 loopargs[i].rsa_key[testnum] = RSA_new();
2482 if (loopargs[i].rsa_key[testnum] == NULL) {
2487 if (!RSA_generate_multi_prime_key(loopargs[i].rsa_key[testnum],
2489 primes, bn, NULL)) {
2495 st = RSA_sign(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2496 &loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2502 "RSA sign failure. No RSA sign will be done.\n");
2503 ERR_print_errors(bio_err);
2506 pkey_print_message("private", "rsa",
2507 rsa_c[testnum][0], rsa_bits[testnum],
2509 /* RSA_blinding_on(rsa_key[testnum],NULL); */
2511 count = run_benchmark(async_jobs, RSA_sign_loop, loopargs);
2514 mr ? "+R1:%ld:%d:%.2f\n"
2515 : "%ld %d bit private RSA's in %.2fs\n",
2516 count, rsa_bits[testnum], d);
2517 rsa_results[testnum][0] = (double)count / d;
2521 for (i = 0; i < loopargs_len; i++) {
2522 st = RSA_verify(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2523 loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2529 "RSA verify failure. No RSA verify will be done.\n");
2530 ERR_print_errors(bio_err);
2531 rsa_doit[testnum] = 0;
2533 pkey_print_message("public", "rsa",
2534 rsa_c[testnum][1], rsa_bits[testnum],
2537 count = run_benchmark(async_jobs, RSA_verify_loop, loopargs);
2540 mr ? "+R2:%ld:%d:%.2f\n"
2541 : "%ld %d bit public RSA's in %.2fs\n",
2542 count, rsa_bits[testnum], d);
2543 rsa_results[testnum][1] = (double)count / d;
2546 if (rsa_count <= 1) {
2547 /* if longer than 10s, don't do any more */
2548 for (testnum++; testnum < RSA_NUM; testnum++)
2549 rsa_doit[testnum] = 0;
2552 #endif /* OPENSSL_NO_RSA */
2554 for (i = 0; i < loopargs_len; i++)
2555 RAND_bytes(loopargs[i].buf, 36);
2557 #ifndef OPENSSL_NO_DSA
2558 for (testnum = 0; testnum < DSA_NUM; testnum++) {
2560 if (!dsa_doit[testnum])
2563 /* DSA_generate_key(dsa_key[testnum]); */
2564 /* DSA_sign_setup(dsa_key[testnum],NULL); */
2565 for (i = 0; i < loopargs_len; i++) {
2566 st = DSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2567 &loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2573 "DSA sign failure. No DSA sign will be done.\n");
2574 ERR_print_errors(bio_err);
2577 pkey_print_message("sign", "dsa",
2578 dsa_c[testnum][0], dsa_bits[testnum],
2581 count = run_benchmark(async_jobs, DSA_sign_loop, loopargs);
2584 mr ? "+R3:%ld:%d:%.2f\n"
2585 : "%ld %d bit DSA signs in %.2fs\n",
2586 count, dsa_bits[testnum], d);
2587 dsa_results[testnum][0] = (double)count / d;
2591 for (i = 0; i < loopargs_len; i++) {
2592 st = DSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2593 loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2599 "DSA verify failure. No DSA verify will be done.\n");
2600 ERR_print_errors(bio_err);
2601 dsa_doit[testnum] = 0;
2603 pkey_print_message("verify", "dsa",
2604 dsa_c[testnum][1], dsa_bits[testnum],
2607 count = run_benchmark(async_jobs, DSA_verify_loop, loopargs);
2610 mr ? "+R4:%ld:%d:%.2f\n"
2611 : "%ld %d bit DSA verify in %.2fs\n",
2612 count, dsa_bits[testnum], d);
2613 dsa_results[testnum][1] = (double)count / d;
2616 if (rsa_count <= 1) {
2617 /* if longer than 10s, don't do any more */
2618 for (testnum++; testnum < DSA_NUM; testnum++)
2619 dsa_doit[testnum] = 0;
2622 #endif /* OPENSSL_NO_DSA */
2624 #ifndef OPENSSL_NO_EC
2625 for (testnum = 0; testnum < EC_NUM; testnum++) {
2628 if (!ecdsa_doit[testnum])
2629 continue; /* Ignore Curve */
2630 for (i = 0; i < loopargs_len; i++) {
2631 loopargs[i].ecdsa[testnum] =
2632 EC_KEY_new_by_curve_name(test_curves[testnum]);
2633 if (loopargs[i].ecdsa[testnum] == NULL) {
2639 BIO_printf(bio_err, "ECDSA failure.\n");
2640 ERR_print_errors(bio_err);
2643 for (i = 0; i < loopargs_len; i++) {
2644 EC_KEY_precompute_mult(loopargs[i].ecdsa[testnum], NULL);
2645 /* Perform ECDSA signature test */
2646 EC_KEY_generate_key(loopargs[i].ecdsa[testnum]);
2647 st = ECDSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2648 &loopargs[i].siglen,
2649 loopargs[i].ecdsa[testnum]);
2655 "ECDSA sign failure. No ECDSA sign will be done.\n");
2656 ERR_print_errors(bio_err);
2659 pkey_print_message("sign", "ecdsa",
2660 ecdsa_c[testnum][0],
2661 test_curves_bits[testnum],
2664 count = run_benchmark(async_jobs, ECDSA_sign_loop, loopargs);
2668 mr ? "+R5:%ld:%d:%.2f\n" :
2669 "%ld %d bit ECDSA signs in %.2fs \n",
2670 count, test_curves_bits[testnum], d);
2671 ecdsa_results[testnum][0] = (double)count / d;
2675 /* Perform ECDSA verification test */
2676 for (i = 0; i < loopargs_len; i++) {
2677 st = ECDSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2679 loopargs[i].ecdsa[testnum]);
2685 "ECDSA verify failure. No ECDSA verify will be done.\n");
2686 ERR_print_errors(bio_err);
2687 ecdsa_doit[testnum] = 0;
2689 pkey_print_message("verify", "ecdsa",
2690 ecdsa_c[testnum][1],
2691 test_curves_bits[testnum],
2694 count = run_benchmark(async_jobs, ECDSA_verify_loop, loopargs);
2697 mr ? "+R6:%ld:%d:%.2f\n"
2698 : "%ld %d bit ECDSA verify in %.2fs\n",
2699 count, test_curves_bits[testnum], d);
2700 ecdsa_results[testnum][1] = (double)count / d;
2703 if (rsa_count <= 1) {
2704 /* if longer than 10s, don't do any more */
2705 for (testnum++; testnum < EC_NUM; testnum++)
2706 ecdsa_doit[testnum] = 0;
2711 for (testnum = 0; testnum < EC_NUM; testnum++) {
2712 int ecdh_checks = 1;
2714 if (!ecdh_doit[testnum])
2717 for (i = 0; i < loopargs_len; i++) {
2718 EVP_PKEY_CTX *kctx = NULL;
2719 EVP_PKEY_CTX *test_ctx = NULL;
2720 EVP_PKEY_CTX *ctx = NULL;
2721 EVP_PKEY *key_A = NULL;
2722 EVP_PKEY *key_B = NULL;
2726 /* Ensure that the error queue is empty */
2727 if (ERR_peek_error()) {
2729 "WARNING: the error queue contains previous unhandled errors.\n");
2730 ERR_print_errors(bio_err);
2733 /* Let's try to create a ctx directly from the NID: this works for
2734 * curves like Curve25519 that are not implemented through the low
2735 * level EC interface.
2736 * If this fails we try creating a EVP_PKEY_EC generic param ctx,
2737 * then we set the curve by NID before deriving the actual keygen
2738 * ctx for that specific curve. */
2739 kctx = EVP_PKEY_CTX_new_id(test_curves[testnum], NULL); /* keygen ctx from NID */
2741 EVP_PKEY_CTX *pctx = NULL;
2742 EVP_PKEY *params = NULL;
2744 /* If we reach this code EVP_PKEY_CTX_new_id() failed and a
2745 * "int_ctx_new:unsupported algorithm" error was added to the
2747 * We remove it from the error queue as we are handling it. */
2748 unsigned long error = ERR_peek_error(); /* peek the latest error in the queue */
2749 if (error == ERR_peek_last_error() && /* oldest and latest errors match */
2750 /* check that the error origin matches */
2751 ERR_GET_LIB(error) == ERR_LIB_EVP &&
2752 ERR_GET_FUNC(error) == EVP_F_INT_CTX_NEW &&
2753 ERR_GET_REASON(error) == EVP_R_UNSUPPORTED_ALGORITHM)
2754 ERR_get_error(); /* pop error from queue */
2755 if (ERR_peek_error()) {
2757 "Unhandled error in the error queue during ECDH init.\n");
2758 ERR_print_errors(bio_err);
2763 if ( /* Create the context for parameter generation */
2764 !(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL)) ||
2765 /* Initialise the parameter generation */
2766 !EVP_PKEY_paramgen_init(pctx) ||
2767 /* Set the curve by NID */
2768 !EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx,
2771 /* Create the parameter object params */
2772 !EVP_PKEY_paramgen(pctx, ¶ms)) {
2774 BIO_printf(bio_err, "ECDH EC params init failure.\n");
2775 ERR_print_errors(bio_err);
2779 /* Create the context for the key generation */
2780 kctx = EVP_PKEY_CTX_new(params, NULL);
2782 EVP_PKEY_free(params);
2784 EVP_PKEY_CTX_free(pctx);
2787 if (kctx == NULL || /* keygen ctx is not null */
2788 !EVP_PKEY_keygen_init(kctx) /* init keygen ctx */ ) {
2790 BIO_printf(bio_err, "ECDH keygen failure.\n");
2791 ERR_print_errors(bio_err);
2796 if (!EVP_PKEY_keygen(kctx, &key_A) || /* generate secret key A */
2797 !EVP_PKEY_keygen(kctx, &key_B) || /* generate secret key B */
2798 !(ctx = EVP_PKEY_CTX_new(key_A, NULL)) || /* derivation ctx from skeyA */
2799 !EVP_PKEY_derive_init(ctx) || /* init derivation ctx */
2800 !EVP_PKEY_derive_set_peer(ctx, key_B) || /* set peer pubkey in ctx */
2801 !EVP_PKEY_derive(ctx, NULL, &outlen) || /* determine max length */
2802 outlen == 0 || /* ensure outlen is a valid size */
2803 outlen > MAX_ECDH_SIZE /* avoid buffer overflow */ ) {
2805 BIO_printf(bio_err, "ECDH key generation failure.\n");
2806 ERR_print_errors(bio_err);
2811 /* Here we perform a test run, comparing the output of a*B and b*A;
2812 * we try this here and assume that further EVP_PKEY_derive calls
2813 * never fail, so we can skip checks in the actually benchmarked
2814 * code, for maximum performance. */
2815 if (!(test_ctx = EVP_PKEY_CTX_new(key_B, NULL)) || /* test ctx from skeyB */
2816 !EVP_PKEY_derive_init(test_ctx) || /* init derivation test_ctx */
2817 !EVP_PKEY_derive_set_peer(test_ctx, key_A) || /* set peer pubkey in test_ctx */
2818 !EVP_PKEY_derive(test_ctx, NULL, &test_outlen) || /* determine max length */
2819 !EVP_PKEY_derive(ctx, loopargs[i].secret_a, &outlen) || /* compute a*B */
2820 !EVP_PKEY_derive(test_ctx, loopargs[i].secret_b, &test_outlen) || /* compute b*A */
2821 test_outlen != outlen /* compare output length */ ) {
2823 BIO_printf(bio_err, "ECDH computation failure.\n");
2824 ERR_print_errors(bio_err);
2829 /* Compare the computation results: CRYPTO_memcmp() returns 0 if equal */
2830 if (CRYPTO_memcmp(loopargs[i].secret_a,
2831 loopargs[i].secret_b, outlen)) {
2833 BIO_printf(bio_err, "ECDH computations don't match.\n");
2834 ERR_print_errors(bio_err);
2839 loopargs[i].ecdh_ctx[testnum] = ctx;
2840 loopargs[i].outlen[testnum] = outlen;
2842 EVP_PKEY_free(key_A);
2843 EVP_PKEY_free(key_B);
2844 EVP_PKEY_CTX_free(kctx);
2846 EVP_PKEY_CTX_free(test_ctx);
2849 if (ecdh_checks != 0) {
2850 pkey_print_message("", "ecdh",
2852 test_curves_bits[testnum],
2856 run_benchmark(async_jobs, ECDH_EVP_derive_key_loop, loopargs);
2859 mr ? "+R7:%ld:%d:%.2f\n" :
2860 "%ld %d-bit ECDH ops in %.2fs\n", count,
2861 test_curves_bits[testnum], d);
2862 ecdh_results[testnum][0] = (double)count / d;
2866 if (rsa_count <= 1) {
2867 /* if longer than 10s, don't do any more */
2868 for (testnum++; testnum < EC_NUM; testnum++)
2869 ecdh_doit[testnum] = 0;
2872 #endif /* OPENSSL_NO_EC */
2877 printf("%s\n", OpenSSL_version(OPENSSL_VERSION));
2878 printf("%s\n", OpenSSL_version(OPENSSL_BUILT_ON));
2880 printf("%s ", BN_options());
2881 #ifndef OPENSSL_NO_MD2
2882 printf("%s ", MD2_options());
2884 #ifndef OPENSSL_NO_RC4
2885 printf("%s ", RC4_options());
2887 #ifndef OPENSSL_NO_DES
2888 printf("%s ", DES_options());
2890 printf("%s ", AES_options());
2891 #ifndef OPENSSL_NO_IDEA
2892 printf("%s ", IDEA_options());
2894 #ifndef OPENSSL_NO_BF
2895 printf("%s ", BF_options());
2897 printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
2905 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2908 for (testnum = 0; testnum < size_num; testnum++)
2909 printf(mr ? ":%d" : "%7d bytes", lengths[testnum]);
2913 for (k = 0; k < ALGOR_NUM; k++) {
2917 printf("+F:%d:%s", k, names[k]);
2919 printf("%-13s", names[k]);
2920 for (testnum = 0; testnum < size_num; testnum++) {
2921 if (results[k][testnum] > 10000 && !mr)
2922 printf(" %11.2fk", results[k][testnum] / 1e3);
2924 printf(mr ? ":%.2f" : " %11.2f ", results[k][testnum]);
2928 #ifndef OPENSSL_NO_RSA
2930 for (k = 0; k < RSA_NUM; k++) {
2933 if (testnum && !mr) {
2934 printf("%18ssign verify sign/s verify/s\n", " ");
2938 printf("+F2:%u:%u:%f:%f\n",
2939 k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2941 printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2942 rsa_bits[k], 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1],
2943 rsa_results[k][0], rsa_results[k][1]);
2946 #ifndef OPENSSL_NO_DSA
2948 for (k = 0; k < DSA_NUM; k++) {
2951 if (testnum && !mr) {
2952 printf("%18ssign verify sign/s verify/s\n", " ");
2956 printf("+F3:%u:%u:%f:%f\n",
2957 k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2959 printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2960 dsa_bits[k], 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1],
2961 dsa_results[k][0], dsa_results[k][1]);
2964 #ifndef OPENSSL_NO_EC
2966 for (k = 0; k < EC_NUM; k++) {
2969 if (testnum && !mr) {
2970 printf("%30ssign verify sign/s verify/s\n", " ");
2975 printf("+F4:%u:%u:%f:%f\n",
2976 k, test_curves_bits[k],
2977 ecdsa_results[k][0], ecdsa_results[k][1]);
2979 printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2980 test_curves_bits[k],
2981 test_curves_names[k],
2982 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1],
2983 ecdsa_results[k][0], ecdsa_results[k][1]);
2987 for (k = 0; k < EC_NUM; k++) {
2990 if (testnum && !mr) {
2991 printf("%30sop op/s\n", " ");
2995 printf("+F5:%u:%u:%f:%f\n",
2996 k, test_curves_bits[k],
2997 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
3000 printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
3001 test_curves_bits[k],
3002 test_curves_names[k],
3003 1.0 / ecdh_results[k][0], ecdh_results[k][0]);
3010 ERR_print_errors(bio_err);
3011 for (i = 0; i < loopargs_len; i++) {
3012 OPENSSL_free(loopargs[i].buf_malloc);
3013 OPENSSL_free(loopargs[i].buf2_malloc);
3015 #ifndef OPENSSL_NO_RSA
3016 for (k = 0; k < RSA_NUM; k++)
3017 RSA_free(loopargs[i].rsa_key[k]);
3019 #ifndef OPENSSL_NO_DSA
3020 for (k = 0; k < DSA_NUM; k++)
3021 DSA_free(loopargs[i].dsa_key[k]);
3023 #ifndef OPENSSL_NO_EC
3024 for (k = 0; k < EC_NUM; k++) {
3025 EC_KEY_free(loopargs[i].ecdsa[k]);
3026 EVP_PKEY_CTX_free(loopargs[i].ecdh_ctx[k]);
3028 OPENSSL_free(loopargs[i].secret_a);
3029 OPENSSL_free(loopargs[i].secret_b);
3033 if (async_jobs > 0) {
3034 for (i = 0; i < loopargs_len; i++)
3035 ASYNC_WAIT_CTX_free(loopargs[i].wait_ctx);
3039 ASYNC_cleanup_thread();
3041 OPENSSL_free(loopargs);
3046 static void print_message(const char *s, long num, int length, int tm)
3050 mr ? "+DT:%s:%d:%d\n"
3051 : "Doing %s for %ds on %d size blocks: ", s, tm, length);
3052 (void)BIO_flush(bio_err);
3056 mr ? "+DN:%s:%ld:%d\n"
3057 : "Doing %s %ld times on %d size blocks: ", s, num, length);
3058 (void)BIO_flush(bio_err);
3062 static void pkey_print_message(const char *str, const char *str2, long num,
3067 mr ? "+DTP:%d:%s:%s:%d\n"
3068 : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
3069 (void)BIO_flush(bio_err);
3073 mr ? "+DNP:%ld:%d:%s:%s\n"
3074 : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
3075 (void)BIO_flush(bio_err);
3079 static void print_result(int alg, int run_no, int count, double time_used)
3082 BIO_puts(bio_err, "EVP error!\n");
3086 mr ? "+R:%d:%s:%f\n"
3087 : "%d %s's in %.2fs\n", count, names[alg], time_used);
3088 results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
3092 static char *sstrsep(char **string, const char *delim)
3095 char *token = *string;
3100 memset(isdelim, 0, sizeof(isdelim));
3104 isdelim[(unsigned char)(*delim)] = 1;
3108 while (!isdelim[(unsigned char)(**string)]) {
3120 static int do_multi(int multi, int size_num)
3125 static char sep[] = ":";
3127 fds = malloc(sizeof(*fds) * multi);
3128 for (n = 0; n < multi; ++n) {
3129 if (pipe(fd) == -1) {
3130 BIO_printf(bio_err, "pipe failure\n");
3134 (void)BIO_flush(bio_err);
3141 if (dup(fd[1]) == -1) {
3142 BIO_printf(bio_err, "dup failed\n");
3151 printf("Forked child %d\n", n);
3154 /* for now, assume the pipe is long enough to take all the output */
3155 for (n = 0; n < multi; ++n) {
3160 f = fdopen(fds[n], "r");
3161 while (fgets(buf, sizeof(buf), f)) {
3162 p = strchr(buf, '\n');
3165 if (buf[0] != '+') {
3167 "Don't understand line '%s' from child %d\n", buf,
3171 printf("Got: %s from %d\n", buf, n);
3172 if (strncmp(buf, "+F:", 3) == 0) {
3177 alg = atoi(sstrsep(&p, sep));
3179 for (j = 0; j < size_num; ++j)
3180 results[alg][j] += atof(sstrsep(&p, sep));
3181 } else if (strncmp(buf, "+F2:", 4) == 0) {
3186 k = atoi(sstrsep(&p, sep));
3189 d = atof(sstrsep(&p, sep));
3190 rsa_results[k][0] += d;
3192 d = atof(sstrsep(&p, sep));
3193 rsa_results[k][1] += d;
3195 # ifndef OPENSSL_NO_DSA
3196 else if (strncmp(buf, "+F3:", 4) == 0) {
3201 k = atoi(sstrsep(&p, sep));
3204 d = atof(sstrsep(&p, sep));
3205 dsa_results[k][0] += d;
3207 d = atof(sstrsep(&p, sep));
3208 dsa_results[k][1] += d;
3211 # ifndef OPENSSL_NO_EC
3212 else if (strncmp(buf, "+F4:", 4) == 0) {
3217 k = atoi(sstrsep(&p, sep));
3220 d = atof(sstrsep(&p, sep));
3221 ecdsa_results[k][0] += d;
3223 d = atof(sstrsep(&p, sep));
3224 ecdsa_results[k][1] += d;
3225 } else if (strncmp(buf, "+F5:", 4) == 0) {
3230 k = atoi(sstrsep(&p, sep));
3233 d = atof(sstrsep(&p, sep));
3234 ecdh_results[k][0] += d;
3238 else if (strncmp(buf, "+H:", 3) == 0) {
3241 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf,
3252 static void multiblock_speed(const EVP_CIPHER *evp_cipher,
3253 const openssl_speed_sec_t *seconds)
3255 static const int mblengths_list[] =
3256 { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
3257 const int *mblengths = mblengths_list;
3258 int j, count, keylen, num = OSSL_NELEM(mblengths_list);
3259 const char *alg_name;
3260 unsigned char *inp, *out, *key, no_key[32], no_iv[16];
3261 EVP_CIPHER_CTX *ctx;
3264 if (lengths_single) {
3265 mblengths = &lengths_single;
3269 inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
3270 out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
3271 ctx = EVP_CIPHER_CTX_new();
3272 EVP_EncryptInit_ex(ctx, evp_cipher, NULL, NULL, no_iv);
3274 keylen = EVP_CIPHER_CTX_key_length(ctx);
3275 key = app_malloc(keylen, "evp_cipher key");
3276 EVP_CIPHER_CTX_rand_key(ctx, key);
3277 EVP_EncryptInit_ex(ctx, NULL, NULL, key, NULL);
3278 OPENSSL_clear_free(key, keylen);
3280 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key), no_key);
3281 alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
3283 for (j = 0; j < num; j++) {
3284 print_message(alg_name, 0, mblengths[j], seconds->sym);
3286 for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
3287 unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
3288 EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
3289 size_t len = mblengths[j];
3292 memset(aad, 0, 8); /* avoid uninitialized values */
3293 aad[8] = 23; /* SSL3_RT_APPLICATION_DATA */
3294 aad[9] = 3; /* version */
3296 aad[11] = 0; /* length */
3298 mb_param.out = NULL;
3301 mb_param.interleave = 8;
3303 packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
3304 sizeof(mb_param), &mb_param);
3310 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
3311 sizeof(mb_param), &mb_param);
3315 RAND_bytes(out, 16);
3317 aad[11] = (unsigned char)(len >> 8);
3318 aad[12] = (unsigned char)(len);
3319 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
3320 EVP_AEAD_TLS1_AAD_LEN, aad);
3321 EVP_Cipher(ctx, out, inp, len + pad);
3325 BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
3326 : "%d %s's in %.2fs\n", count, "evp", d);
3327 results[D_EVP][j] = ((double)count) / d * mblengths[j];
3331 fprintf(stdout, "+H");
3332 for (j = 0; j < num; j++)
3333 fprintf(stdout, ":%d", mblengths[j]);
3334 fprintf(stdout, "\n");
3335 fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
3336 for (j = 0; j < num; j++)
3337 fprintf(stdout, ":%.2f", results[D_EVP][j]);
3338 fprintf(stdout, "\n");
3341 "The 'numbers' are in 1000s of bytes per second processed.\n");
3342 fprintf(stdout, "type ");
3343 for (j = 0; j < num; j++)
3344 fprintf(stdout, "%7d bytes", mblengths[j]);
3345 fprintf(stdout, "\n");
3346 fprintf(stdout, "%-24s", alg_name);
3348 for (j = 0; j < num; j++) {
3349 if (results[D_EVP][j] > 10000)
3350 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
3352 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
3354 fprintf(stdout, "\n");
3359 EVP_CIPHER_CTX_free(ctx);