d2afebb2c6aaff947cb55df49a9daec1d6150660
[openssl.git] / apps / speed.c
1 /*
2  * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.
3  * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
4  *
5  * Licensed under the Apache License 2.0 (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
9  */
10
11 #undef SECONDS
12 #define SECONDS                 3
13 #define RSA_SECONDS             10
14 #define DSA_SECONDS             10
15 #define ECDSA_SECONDS   10
16 #define ECDH_SECONDS    10
17 #define EdDSA_SECONDS   10
18 #define SM2_SECONDS     10
19
20 /* We need to use some deprecated APIs */
21 #define OPENSSL_SUPPRESS_DEPRECATED
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <math.h>
27 #include "apps.h"
28 #include "progs.h"
29 #include <openssl/crypto.h>
30 #include <openssl/rand.h>
31 #include <openssl/err.h>
32 #include <openssl/evp.h>
33 #include <openssl/objects.h>
34 #include <openssl/async.h>
35 #if !defined(OPENSSL_SYS_MSDOS)
36 # include <unistd.h>
37 #endif
38
39 #if defined(_WIN32)
40 # include <windows.h>
41 #endif
42
43 #include <openssl/bn.h>
44 #ifndef OPENSSL_NO_DES
45 # include <openssl/des.h>
46 #endif
47 #ifndef OPENSSL_NO_DEPRECATED_3_0
48 #include <openssl/aes.h>
49 #endif
50 #ifndef OPENSSL_NO_CAMELLIA
51 # include <openssl/camellia.h>
52 #endif
53 #ifndef OPENSSL_NO_MD2
54 # include <openssl/md2.h>
55 #endif
56 #ifndef OPENSSL_NO_MDC2
57 # include <openssl/mdc2.h>
58 #endif
59 #ifndef OPENSSL_NO_MD4
60 # include <openssl/md4.h>
61 #endif
62 #ifndef OPENSSL_NO_MD5
63 # include <openssl/md5.h>
64 #endif
65 #include <openssl/hmac.h>
66 #ifndef OPENSSL_NO_CMAC
67 #include <openssl/cmac.h>
68 #endif
69 #include <openssl/sha.h>
70 #ifndef OPENSSL_NO_RMD160
71 # include <openssl/ripemd.h>
72 #endif
73 #ifndef OPENSSL_NO_WHIRLPOOL
74 # include <openssl/whrlpool.h>
75 #endif
76 #ifndef OPENSSL_NO_RC4
77 # include <openssl/rc4.h>
78 #endif
79 #ifndef OPENSSL_NO_RC5
80 # include <openssl/rc5.h>
81 #endif
82 #ifndef OPENSSL_NO_RC2
83 # include <openssl/rc2.h>
84 #endif
85 #ifndef OPENSSL_NO_IDEA
86 # include <openssl/idea.h>
87 #endif
88 #ifndef OPENSSL_NO_SEED
89 # include <openssl/seed.h>
90 #endif
91 #ifndef OPENSSL_NO_BF
92 # include <openssl/blowfish.h>
93 #endif
94 #ifndef OPENSSL_NO_CAST
95 # include <openssl/cast.h>
96 #endif
97 #ifndef OPENSSL_NO_RSA
98 # include <openssl/rsa.h>
99 # include "./testrsa.h"
100 #endif
101 #include <openssl/x509.h>
102 #ifndef OPENSSL_NO_DSA
103 # include <openssl/dsa.h>
104 # include "./testdsa.h"
105 #endif
106 #ifndef OPENSSL_NO_EC
107 # include <openssl/ec.h>
108 #endif
109 #include <openssl/modes.h>
110
111 #ifndef HAVE_FORK
112 # if defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_VXWORKS)
113 #  define HAVE_FORK 0
114 # else
115 #  define HAVE_FORK 1
116 # endif
117 #endif
118
119 #if HAVE_FORK
120 # undef NO_FORK
121 #else
122 # define NO_FORK
123 #endif
124
125 #define MAX_MISALIGNMENT 63
126 #define MAX_ECDH_SIZE   256
127 #define MISALIGN        64
128
129 typedef struct openssl_speed_sec_st {
130     int sym;
131     int rsa;
132     int dsa;
133     int ecdsa;
134     int ecdh;
135     int eddsa;
136     int sm2;
137 } openssl_speed_sec_t;
138
139 static volatile int run = 0;
140
141 static int mr = 0;  /* machine-readeable output format to merge fork results */
142 static int usertime = 1;
143
144 static double Time_F(int s);
145 static void print_message(const char *s, long num, int length, int tm);
146 static void pkey_print_message(const char *str, const char *str2,
147                                long num, unsigned int bits, int sec);
148 static void print_result(int alg, int run_no, int count, double time_used);
149 #ifndef NO_FORK
150 static int do_multi(int multi, int size_num);
151 #endif
152
153 static const int lengths_list[] = {
154     16, 64, 256, 1024, 8 * 1024, 16 * 1024
155 };
156 #define SIZE_NUM         OSSL_NELEM(lengths_list)
157 static const int *lengths = lengths_list;
158
159 static const int aead_lengths_list[] = {
160     2, 31, 136, 1024, 8 * 1024, 16 * 1024
161 };
162
163 #define START   0
164 #define STOP    1
165
166 #ifdef SIGALRM
167
168 static void alarmed(int sig)
169 {
170     signal(SIGALRM, alarmed);
171     run = 0;
172 }
173
174 static double Time_F(int s)
175 {
176     double ret = app_tminterval(s, usertime);
177     if (s == STOP)
178         alarm(0);
179     return ret;
180 }
181
182 #elif defined(_WIN32)
183
184 # define SIGALRM -1
185
186 static unsigned int lapse;
187 static volatile unsigned int schlock;
188 static void alarm_win32(unsigned int secs)
189 {
190     lapse = secs * 1000;
191 }
192
193 # define alarm alarm_win32
194
195 static DWORD WINAPI sleepy(VOID * arg)
196 {
197     schlock = 1;
198     Sleep(lapse);
199     run = 0;
200     return 0;
201 }
202
203 static double Time_F(int s)
204 {
205     double ret;
206     static HANDLE thr;
207
208     if (s == START) {
209         schlock = 0;
210         thr = CreateThread(NULL, 4096, sleepy, NULL, 0, NULL);
211         if (thr == NULL) {
212             DWORD err = GetLastError();
213             BIO_printf(bio_err, "unable to CreateThread (%lu)", err);
214             ExitProcess(err);
215         }
216         while (!schlock)
217             Sleep(0);           /* scheduler spinlock */
218         ret = app_tminterval(s, usertime);
219     } else {
220         ret = app_tminterval(s, usertime);
221         if (run)
222             TerminateThread(thr, 0);
223         CloseHandle(thr);
224     }
225
226     return ret;
227 }
228 #else
229 static double Time_F(int s)
230 {
231     return app_tminterval(s, usertime);
232 }
233 #endif
234
235 static void multiblock_speed(const EVP_CIPHER *evp_cipher, int lengths_single,
236                              const openssl_speed_sec_t *seconds);
237
238 static int opt_found(const char *name, unsigned int *result,
239                      const OPT_PAIR pairs[], unsigned int nbelem)
240 {
241     unsigned int idx;
242
243     for (idx = 0; idx < nbelem; ++idx, pairs++)
244         if (strcmp(name, pairs->name) == 0) {
245             *result = pairs->retval;
246             return 1;
247         }
248     return 0;
249 }
250 #define opt_found(value, pairs, result)\
251     opt_found(value, result, pairs, OSSL_NELEM(pairs))
252
253 typedef enum OPTION_choice {
254     OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
255     OPT_ELAPSED, OPT_EVP, OPT_HMAC, OPT_DECRYPT, OPT_ENGINE, OPT_MULTI,
256     OPT_MR, OPT_MB, OPT_MISALIGN, OPT_ASYNCJOBS, OPT_R_ENUM,
257     OPT_PRIMES, OPT_SECONDS, OPT_BYTES, OPT_AEAD, OPT_CMAC
258 } OPTION_CHOICE;
259
260 const OPTIONS speed_options[] = {
261     {OPT_HELP_STR, 1, '-', "Usage: %s [options] [algorithm...]\n"},
262
263     OPT_SECTION("General"),
264     {"help", OPT_HELP, '-', "Display this summary"},
265     {"mb", OPT_MB, '-',
266      "Enable (tls1>=1) multi-block mode on EVP-named cipher"},
267     {"mr", OPT_MR, '-', "Produce machine readable output"},
268 #ifndef NO_FORK
269     {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"},
270 #endif
271 #ifndef OPENSSL_NO_ASYNC
272     {"async_jobs", OPT_ASYNCJOBS, 'p',
273      "Enable async mode and start specified number of jobs"},
274 #endif
275 #ifndef OPENSSL_NO_ENGINE
276     {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
277 #endif
278     {"primes", OPT_PRIMES, 'p', "Specify number of primes (for RSA only)"},
279
280     OPT_SECTION("Selection"),
281     {"evp", OPT_EVP, 's', "Use EVP-named cipher or digest"},
282 #ifndef OPENSSL_NO_DEPRECATED_3_0
283     {"hmac", OPT_HMAC, 's', "HMAC using EVP-named digest"},
284 #endif
285 #if !defined(OPENSSL_NO_CMAC) && !defined(OPENSSL_NO_DEPRECATED_3_0)
286     {"cmac", OPT_CMAC, 's', "CMAC using EVP-named cipher"},
287 #endif
288     {"decrypt", OPT_DECRYPT, '-',
289      "Time decryption instead of encryption (only EVP)"},
290     {"aead", OPT_AEAD, '-',
291      "Benchmark EVP-named AEAD cipher in TLS-like sequence"},
292
293     OPT_SECTION("Timing"),
294     {"elapsed", OPT_ELAPSED, '-',
295      "Use wall-clock time instead of CPU user time as divisor"},
296     {"seconds", OPT_SECONDS, 'p',
297      "Run benchmarks for specified amount of seconds"},
298     {"bytes", OPT_BYTES, 'p',
299      "Run [non-PKI] benchmarks on custom-sized buffer"},
300     {"misalign", OPT_MISALIGN, 'p',
301      "Use specified offset to mis-align buffers"},
302
303     OPT_R_OPTIONS,
304
305     OPT_PARAMETERS(),
306     {"algorithm", 0, 0, "Algorithm(s) to test (optional; otherwise tests all)"},
307     {NULL}
308 };
309
310 enum {
311     D_MD2, D_MDC2, D_MD4, D_MD5 , D_HMAC, D_SHA1, D_RMD160, D_RC4,
312     D_CBC_DES, D_EDE3_DES, D_CBC_IDEA, D_CBC_SEED,
313     D_CBC_RC2, D_CBC_RC5, D_CBC_BF, D_CBC_CAST,
314     D_CBC_128_AES, D_CBC_192_AES, D_CBC_256_AES,
315     D_CBC_128_CML, D_CBC_192_CML, D_CBC_256_CML,
316     D_EVP, D_SHA256, D_SHA512, D_WHIRLPOOL,
317     D_IGE_128_AES, D_IGE_192_AES, D_IGE_256_AES,
318     D_GHASH, D_RAND, D_EVP_HMAC, D_EVP_CMAC, ALGOR_NUM 
319 };
320 /* name of algorithms to test. MUST BE KEEP IN SYNC with above enum ! */
321 static const char *names[ALGOR_NUM] = {
322     "md2", "mdc2", "md4", "md5", "hmac(md5)", "sha1", "rmd160", "rc4",
323     "des cbc", "des ede3", "idea cbc", "seed cbc",
324     "rc2 cbc", "rc5-32/12 cbc", "blowfish cbc", "cast cbc",
325     "aes-128 cbc", "aes-192 cbc", "aes-256 cbc",
326     "camellia-128 cbc", "camellia-192 cbc", "camellia-256 cbc",
327     "evp", "sha256", "sha512", "whirlpool",
328     "aes-128 ige", "aes-192 ige", "aes-256 ige", "ghash",
329     "rand", "hmac", "cmac"
330 };
331
332 /* list of configured algorithm (remaining), with some few alias */
333 static const OPT_PAIR doit_choices[] = {
334 #if !defined(OPENSSL_NO_MD2) && !defined(OPENSSL_NO_DEPRECATED_3_0)
335     {"md2", D_MD2},
336 #endif
337 #if !defined(OPENSSL_NO_MDC2) && !defined(OPENSSL_NO_DEPRECATED_3_0)
338     {"mdc2", D_MDC2},
339 #endif
340 #if !defined(OPENSSL_NO_MD4) && !defined(OPENSSL_NO_DEPRECATED_3_0)
341     {"md4", D_MD4},
342 #endif
343 #if !defined(OPENSSL_NO_MD5) && !defined(OPENSSL_NO_DEPRECATED_3_0)
344     {"md5", D_MD5},
345 # ifndef OPENSSL_NO_DEPRECATED_3_0
346     {"hmac", D_HMAC},
347 # endif
348 #endif
349 #ifndef OPENSSL_NO_DEPRECATED_3_0
350     {"sha1", D_SHA1},
351     {"sha256", D_SHA256},
352     {"sha512", D_SHA512},
353 #endif
354 #if !defined(OPENSSL_NO_WHIRLPOOL) && !defined(OPENSSL_NO_DEPRECATED_3_0)
355     {"whirlpool", D_WHIRLPOOL},
356 #endif
357 #if !defined(OPENSSL_NO_RMD160) && !defined(OPENSSL_NO_DEPRECATED_3_0)
358     {"ripemd", D_RMD160},
359     {"rmd160", D_RMD160},
360     {"ripemd160", D_RMD160},
361 #endif
362 #if !defined(OPENSSL_NO_RC4) && !defined(OPENSSL_NO_DEPRECATED_3_0)
363     {"rc4", D_RC4},
364 #endif
365 #if !defined(OPENSSL_NO_DES) && !defined(OPENSSL_NO_DEPRECATED_3_0)
366     {"des-cbc", D_CBC_DES},
367     {"des-ede3", D_EDE3_DES},
368 #endif
369 #ifndef OPENSSL_NO_DEPRECATED_3_0
370     {"aes-128-cbc", D_CBC_128_AES},
371     {"aes-192-cbc", D_CBC_192_AES},
372     {"aes-256-cbc", D_CBC_256_AES},
373     {"aes-128-ige", D_IGE_128_AES},
374     {"aes-192-ige", D_IGE_192_AES},
375     {"aes-256-ige", D_IGE_256_AES},
376 #endif
377 #if !defined(OPENSSL_NO_RC2) && !defined(OPENSSL_NO_DEPRECATED_3_0)
378     {"rc2-cbc", D_CBC_RC2},
379     {"rc2", D_CBC_RC2},
380 #endif
381 #if !defined(OPENSSL_NO_RC5) && !defined(OPENSSL_NO_DEPRECATED_3_0)
382     {"rc5-cbc", D_CBC_RC5},
383     {"rc5", D_CBC_RC5},
384 #endif
385 #if !defined(OPENSSL_NO_IDEA) && !defined(OPENSSL_NO_DEPRECATED_3_0)
386     {"idea-cbc", D_CBC_IDEA},
387     {"idea", D_CBC_IDEA},
388 #endif
389 #if !defined(OPENSSL_NO_SEED) && !defined(OPENSSL_NO_DEPRECATED_3_0)
390     {"seed-cbc", D_CBC_SEED},
391     {"seed", D_CBC_SEED},
392 #endif
393 #if !defined(OPENSSL_NO_BF) && !defined(OPENSSL_NO_DEPRECATED_3_0)
394     {"bf-cbc", D_CBC_BF},
395     {"blowfish", D_CBC_BF},
396     {"bf", D_CBC_BF},
397 #endif
398 #if !defined(OPENSSL_NO_CAST) && !defined(OPENSSL_NO_DEPRECATED_3_0)
399     {"cast-cbc", D_CBC_CAST},
400     {"cast", D_CBC_CAST},
401     {"cast5", D_CBC_CAST},
402 #endif
403     {"ghash", D_GHASH},
404     {"rand", D_RAND}
405 };
406
407 static double results[ALGOR_NUM][SIZE_NUM];
408
409 #ifndef OPENSSL_NO_DSA
410 enum { R_DSA_512, R_DSA_1024, R_DSA_2048, DSA_NUM };
411 static const OPT_PAIR dsa_choices[DSA_NUM] = {
412     {"dsa512", R_DSA_512},
413     {"dsa1024", R_DSA_1024},
414     {"dsa2048", R_DSA_2048}
415 };
416 static double dsa_results[DSA_NUM][2];  /* 2 ops: sign then verify */
417 #endif  /* OPENSSL_NO_DSA */
418
419 #ifndef OPENSSL_NO_RSA
420 enum {
421     R_RSA_512, R_RSA_1024, R_RSA_2048, R_RSA_3072, R_RSA_4096, R_RSA_7680,
422     R_RSA_15360, RSA_NUM
423 };
424 static const OPT_PAIR rsa_choices[RSA_NUM] = {
425     {"rsa512", R_RSA_512},
426     {"rsa1024", R_RSA_1024},
427     {"rsa2048", R_RSA_2048},
428     {"rsa3072", R_RSA_3072},
429     {"rsa4096", R_RSA_4096},
430     {"rsa7680", R_RSA_7680},
431     {"rsa15360", R_RSA_15360}
432 };
433
434 static double rsa_results[RSA_NUM][2];  /* 2 ops: sign then verify */
435 #endif /* OPENSSL_NO_RSA */
436
437 #ifndef OPENSSL_NO_EC
438 enum ec_curves_t {
439     R_EC_P160, R_EC_P192, R_EC_P224, R_EC_P256, R_EC_P384, R_EC_P521,
440 # ifndef OPENSSL_NO_EC2M
441     R_EC_K163, R_EC_K233, R_EC_K283, R_EC_K409, R_EC_K571,
442     R_EC_B163, R_EC_B233, R_EC_B283, R_EC_B409, R_EC_B571,
443 # endif
444     R_EC_BRP256R1, R_EC_BRP256T1, R_EC_BRP384R1, R_EC_BRP384T1,
445     R_EC_BRP512R1, R_EC_BRP512T1, ECDSA_NUM
446 };
447 /* list of ecdsa curves */
448 static const OPT_PAIR ecdsa_choices[ECDSA_NUM] = {
449     {"ecdsap160", R_EC_P160},
450     {"ecdsap192", R_EC_P192},
451     {"ecdsap224", R_EC_P224},
452     {"ecdsap256", R_EC_P256},
453     {"ecdsap384", R_EC_P384},
454     {"ecdsap521", R_EC_P521},
455 # ifndef OPENSSL_NO_EC2M
456     {"ecdsak163", R_EC_K163},
457     {"ecdsak233", R_EC_K233},
458     {"ecdsak283", R_EC_K283},
459     {"ecdsak409", R_EC_K409},
460     {"ecdsak571", R_EC_K571},
461     {"ecdsab163", R_EC_B163},
462     {"ecdsab233", R_EC_B233},
463     {"ecdsab283", R_EC_B283},
464     {"ecdsab409", R_EC_B409},
465     {"ecdsab571", R_EC_B571},
466 # endif
467     {"ecdsabrp256r1", R_EC_BRP256R1},
468     {"ecdsabrp256t1", R_EC_BRP256T1},
469     {"ecdsabrp384r1", R_EC_BRP384R1},
470     {"ecdsabrp384t1", R_EC_BRP384T1},
471     {"ecdsabrp512r1", R_EC_BRP512R1},
472     {"ecdsabrp512t1", R_EC_BRP512T1}
473 };
474 enum { R_EC_X25519 = ECDSA_NUM, R_EC_X448, EC_NUM };
475 /* list of ecdh curves, extension of |ecdsa_choices| list above */
476 static const OPT_PAIR ecdh_choices[EC_NUM] = {
477     {"ecdhp160", R_EC_P160},
478     {"ecdhp192", R_EC_P192},
479     {"ecdhp224", R_EC_P224},
480     {"ecdhp256", R_EC_P256},
481     {"ecdhp384", R_EC_P384},
482     {"ecdhp521", R_EC_P521},
483 # ifndef OPENSSL_NO_EC2M
484     {"ecdhk163", R_EC_K163},
485     {"ecdhk233", R_EC_K233},
486     {"ecdhk283", R_EC_K283},
487     {"ecdhk409", R_EC_K409},
488     {"ecdhk571", R_EC_K571},
489     {"ecdhb163", R_EC_B163},
490     {"ecdhb233", R_EC_B233},
491     {"ecdhb283", R_EC_B283},
492     {"ecdhb409", R_EC_B409},
493     {"ecdhb571", R_EC_B571},
494 # endif
495     {"ecdhbrp256r1", R_EC_BRP256R1},
496     {"ecdhbrp256t1", R_EC_BRP256T1},
497     {"ecdhbrp384r1", R_EC_BRP384R1},
498     {"ecdhbrp384t1", R_EC_BRP384T1},
499     {"ecdhbrp512r1", R_EC_BRP512R1},
500     {"ecdhbrp512t1", R_EC_BRP512T1},
501     {"ecdhx25519", R_EC_X25519},
502     {"ecdhx448", R_EC_X448}
503 };
504
505 static double ecdh_results[EC_NUM][1];      /* 1 op: derivation */
506 static double ecdsa_results[ECDSA_NUM][2];  /* 2 ops: sign then verify */
507
508 enum { R_EC_Ed25519, R_EC_Ed448, EdDSA_NUM };
509 static const OPT_PAIR eddsa_choices[EdDSA_NUM] = {
510     {"ed25519", R_EC_Ed25519},
511     {"ed448", R_EC_Ed448}
512
513 };
514 static double eddsa_results[EdDSA_NUM][2];    /* 2 ops: sign then verify */
515
516 # ifndef OPENSSL_NO_SM2
517 enum { R_EC_CURVESM2, SM2_NUM };
518 static const OPT_PAIR sm2_choices[SM2_NUM] = {
519     {"curveSM2", R_EC_CURVESM2}
520 };
521 #  define SM2_ID        "TLSv1.3+GM+Cipher+Suite"
522 #  define SM2_ID_LEN    sizeof("TLSv1.3+GM+Cipher+Suite") - 1
523 static double sm2_results[SM2_NUM][2];    /* 2 ops: sign then verify */
524 # endif /* OPENSSL_NO_SM2 */
525 #endif /* OPENSSL_NO_EC */
526
527 #ifndef SIGALRM
528 # define COND(d) (count < (d))
529 # define COUNT(d) (d)
530 #else
531 # define COND(unused_cond) (run && count<0x7fffffff)
532 # define COUNT(d) (count)
533 #endif                          /* SIGALRM */
534
535 typedef struct loopargs_st {
536     ASYNC_JOB *inprogress_job;
537     ASYNC_WAIT_CTX *wait_ctx;
538     unsigned char *buf;
539     unsigned char *buf2;
540     unsigned char *buf_malloc;
541     unsigned char *buf2_malloc;
542     unsigned char *key;
543     unsigned int siglen;
544     size_t sigsize;
545 #ifndef OPENSSL_NO_RSA
546     RSA *rsa_key[RSA_NUM];
547 #endif
548 #ifndef OPENSSL_NO_DSA
549     DSA *dsa_key[DSA_NUM];
550 #endif
551 #ifndef OPENSSL_NO_EC
552     EC_KEY *ecdsa[ECDSA_NUM];
553     EVP_PKEY_CTX *ecdh_ctx[EC_NUM];
554     EVP_MD_CTX *eddsa_ctx[EdDSA_NUM];
555 # ifndef OPENSSL_NO_SM2
556     EVP_MD_CTX *sm2_ctx[SM2_NUM];
557     EVP_MD_CTX *sm2_vfy_ctx[SM2_NUM];
558     EVP_PKEY *sm2_pkey[SM2_NUM];
559 # endif
560     unsigned char *secret_a;
561     unsigned char *secret_b;
562     size_t outlen[EC_NUM];
563 #endif
564     EVP_CIPHER_CTX *ctx;
565 #ifndef OPENSSL_NO_DEPRECATED_3_0
566     HMAC_CTX *hctx;
567 #endif
568 #if !defined(OPENSSL_NO_CMAC) && !defined(OPENSSL_NO_DEPRECATED_3_0)
569     CMAC_CTX *cmac_ctx;
570 #endif
571     GCM128_CONTEXT *gcm_ctx;
572 } loopargs_t;
573 static int run_benchmark(int async_jobs, int (*loop_function) (void *),
574                          loopargs_t * loopargs);
575
576 static unsigned int testnum;
577
578 /* Nb of iterations to do per algorithm and key-size */
579 static long c[ALGOR_NUM][SIZE_NUM];
580
581 #if !defined(OPENSSL_NO_MD2) && !defined(OPENSSL_NO_DEPRECATED_3_0)
582 static int EVP_Digest_MD2_loop(void *args)
583 {
584     loopargs_t *tempargs = *(loopargs_t **) args;
585     unsigned char *buf = tempargs->buf;
586     unsigned char md2[MD2_DIGEST_LENGTH];
587     int count;
588
589     for (count = 0; COND(c[D_MD2][testnum]); count++) {
590         if (!EVP_Digest(buf, (size_t)lengths[testnum], md2, NULL, EVP_md2(),
591                         NULL))
592             return -1;
593     }
594     return count;
595 }
596 #endif
597
598 #if !defined(OPENSSL_NO_MDC2) && !defined(OPENSSL_NO_DEPRECATED_3_0)
599 static int EVP_Digest_MDC2_loop(void *args)
600 {
601     loopargs_t *tempargs = *(loopargs_t **) args;
602     unsigned char *buf = tempargs->buf;
603     unsigned char mdc2[MDC2_DIGEST_LENGTH];
604     int count;
605
606     for (count = 0; COND(c[D_MDC2][testnum]); count++) {
607         if (!EVP_Digest(buf, (size_t)lengths[testnum], mdc2, NULL, EVP_mdc2(),
608                         NULL))
609             return -1;
610     }
611     return count;
612 }
613 #endif
614
615 #if !defined(OPENSSL_NO_MD4) && !defined(OPENSSL_NO_DEPRECATED_3_0)
616 static int EVP_Digest_MD4_loop(void *args)
617 {
618     loopargs_t *tempargs = *(loopargs_t **) args;
619     unsigned char *buf = tempargs->buf;
620     unsigned char md4[MD4_DIGEST_LENGTH];
621     int count;
622
623     for (count = 0; COND(c[D_MD4][testnum]); count++) {
624         if (!EVP_Digest(buf, (size_t)lengths[testnum], md4, NULL, EVP_md4(),
625                         NULL))
626             return -1;
627     }
628     return count;
629 }
630 #endif
631
632 #if !defined(OPENSSL_NO_MD5) && !defined(OPENSSL_NO_DEPRECATED_3_0)
633 static int MD5_loop(void *args)
634 {
635     loopargs_t *tempargs = *(loopargs_t **) args;
636     unsigned char *buf = tempargs->buf;
637     unsigned char md5[MD5_DIGEST_LENGTH];
638     int count;
639     for (count = 0; COND(c[D_MD5][testnum]); count++)
640         MD5(buf, lengths[testnum], md5);
641     return count;
642 }
643
644 # ifndef OPENSSL_NO_DEPRECATED_3_0
645 static int HMAC_loop(void *args)
646 {
647     loopargs_t *tempargs = *(loopargs_t **) args;
648     unsigned char *buf = tempargs->buf;
649     HMAC_CTX *hctx = tempargs->hctx;
650     unsigned char hmac[MD5_DIGEST_LENGTH];
651     int count;
652
653     for (count = 0; COND(c[D_HMAC][testnum]); count++) {
654         HMAC_Init_ex(hctx, NULL, 0, NULL, NULL);
655         HMAC_Update(hctx, buf, lengths[testnum]);
656         HMAC_Final(hctx, hmac, NULL);
657     }
658     return count;
659 }
660 # endif
661 #endif
662
663 #ifndef OPENSSL_NO_DEPRECATED_3_0
664 static int SHA1_loop(void *args)
665 {
666     loopargs_t *tempargs = *(loopargs_t **) args;
667     unsigned char *buf = tempargs->buf;
668     unsigned char sha[SHA_DIGEST_LENGTH];
669     int count;
670     for (count = 0; COND(c[D_SHA1][testnum]); count++)
671         SHA1(buf, lengths[testnum], sha);
672     return count;
673 }
674
675 static int SHA256_loop(void *args)
676 {
677     loopargs_t *tempargs = *(loopargs_t **) args;
678     unsigned char *buf = tempargs->buf;
679     unsigned char sha256[SHA256_DIGEST_LENGTH];
680     int count;
681     for (count = 0; COND(c[D_SHA256][testnum]); count++)
682         SHA256(buf, lengths[testnum], sha256);
683     return count;
684 }
685
686 static int SHA512_loop(void *args)
687 {
688     loopargs_t *tempargs = *(loopargs_t **) args;
689     unsigned char *buf = tempargs->buf;
690     unsigned char sha512[SHA512_DIGEST_LENGTH];
691     int count;
692     for (count = 0; COND(c[D_SHA512][testnum]); count++)
693         SHA512(buf, lengths[testnum], sha512);
694     return count;
695 }
696 #endif
697
698 #if !defined(OPENSSL_NO_WHIRLPOOL) && !defined(OPENSSL_NO_DEPRECATED_3_0)
699 static int WHIRLPOOL_loop(void *args)
700 {
701     loopargs_t *tempargs = *(loopargs_t **) args;
702     unsigned char *buf = tempargs->buf;
703     unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];
704     int count;
705     for (count = 0; COND(c[D_WHIRLPOOL][testnum]); count++)
706         WHIRLPOOL(buf, lengths[testnum], whirlpool);
707     return count;
708 }
709 #endif
710
711 #if !defined(OPENSSL_NO_RMD160) && !defined(OPENSSL_NO_DEPRECATED_3_0)
712 static int EVP_Digest_RMD160_loop(void *args)
713 {
714     loopargs_t *tempargs = *(loopargs_t **) args;
715     unsigned char *buf = tempargs->buf;
716     unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
717     int count;
718     for (count = 0; COND(c[D_RMD160][testnum]); count++) {
719         if (!EVP_Digest(buf, (size_t)lengths[testnum], &(rmd160[0]),
720                         NULL, EVP_ripemd160(), NULL))
721             return -1;
722     }
723     return count;
724 }
725 #endif
726
727 #if !defined(OPENSSL_NO_RC4) && !defined(OPENSSL_NO_DEPRECATED_3_0)
728 static RC4_KEY rc4_ks;
729 static int RC4_loop(void *args)
730 {
731     loopargs_t *tempargs = *(loopargs_t **) args;
732     unsigned char *buf = tempargs->buf;
733     int count;
734     for (count = 0; COND(c[D_RC4][testnum]); count++)
735         RC4(&rc4_ks, (size_t)lengths[testnum], buf, buf);
736     return count;
737 }
738 #endif
739
740 #if !defined(OPENSSL_NO_DES) && !defined(OPENSSL_NO_DEPRECATED_3_0)
741 static unsigned char DES_iv[8];
742 static DES_key_schedule sch[3];
743 static int DES_ncbc_encrypt_loop(void *args)
744 {
745     loopargs_t *tempargs = *(loopargs_t **) args;
746     unsigned char *buf = tempargs->buf;
747     int count;
748     for (count = 0; COND(c[D_CBC_DES][testnum]); count++)
749         DES_ncbc_encrypt(buf, buf, lengths[testnum], &sch[0],
750                          &DES_iv, DES_ENCRYPT);
751     return count;
752 }
753
754 static int DES_ede3_cbc_encrypt_loop(void *args)
755 {
756     loopargs_t *tempargs = *(loopargs_t **) args;
757     unsigned char *buf = tempargs->buf;
758     int count;
759     for (count = 0; COND(c[D_EDE3_DES][testnum]); count++)
760         DES_ede3_cbc_encrypt(buf, buf, lengths[testnum],
761                              &sch[0], &sch[1], &sch[2], &DES_iv, DES_ENCRYPT);
762     return count;
763 }
764 #endif
765
766 #define MAX_BLOCK_SIZE 128
767
768 static unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
769
770 #ifndef OPENSSL_NO_DEPRECATED_3_0
771 static AES_KEY aes_ks1, aes_ks2, aes_ks3;
772 static int AES_cbc_128_encrypt_loop(void *args)
773 {
774     loopargs_t *tempargs = *(loopargs_t **) args;
775     unsigned char *buf = tempargs->buf;
776     int count;
777     for (count = 0; COND(c[D_CBC_128_AES][testnum]); count++)
778         AES_cbc_encrypt(buf, buf,
779                         (size_t)lengths[testnum], &aes_ks1, iv, AES_ENCRYPT);
780     return count;
781 }
782
783 static int AES_cbc_192_encrypt_loop(void *args)
784 {
785     loopargs_t *tempargs = *(loopargs_t **) args;
786     unsigned char *buf = tempargs->buf;
787     int count;
788     for (count = 0; COND(c[D_CBC_192_AES][testnum]); count++)
789         AES_cbc_encrypt(buf, buf,
790                         (size_t)lengths[testnum], &aes_ks2, iv, AES_ENCRYPT);
791     return count;
792 }
793
794 static int AES_cbc_256_encrypt_loop(void *args)
795 {
796     loopargs_t *tempargs = *(loopargs_t **) args;
797     unsigned char *buf = tempargs->buf;
798     int count;
799     for (count = 0; COND(c[D_CBC_256_AES][testnum]); count++)
800         AES_cbc_encrypt(buf, buf,
801                         (size_t)lengths[testnum], &aes_ks3, iv, AES_ENCRYPT);
802     return count;
803 }
804
805 static int AES_ige_128_encrypt_loop(void *args)
806 {
807     loopargs_t *tempargs = *(loopargs_t **) args;
808     unsigned char *buf = tempargs->buf;
809     unsigned char *buf2 = tempargs->buf2;
810     int count;
811     for (count = 0; COND(c[D_IGE_128_AES][testnum]); count++)
812         AES_ige_encrypt(buf, buf2,
813                         (size_t)lengths[testnum], &aes_ks1, iv, AES_ENCRYPT);
814     return count;
815 }
816
817 static int AES_ige_192_encrypt_loop(void *args)
818 {
819     loopargs_t *tempargs = *(loopargs_t **) args;
820     unsigned char *buf = tempargs->buf;
821     unsigned char *buf2 = tempargs->buf2;
822     int count;
823     for (count = 0; COND(c[D_IGE_192_AES][testnum]); count++)
824         AES_ige_encrypt(buf, buf2,
825                         (size_t)lengths[testnum], &aes_ks2, iv, AES_ENCRYPT);
826     return count;
827 }
828
829 static int AES_ige_256_encrypt_loop(void *args)
830 {
831     loopargs_t *tempargs = *(loopargs_t **) args;
832     unsigned char *buf = tempargs->buf;
833     unsigned char *buf2 = tempargs->buf2;
834     int count;
835     for (count = 0; COND(c[D_IGE_256_AES][testnum]); count++)
836         AES_ige_encrypt(buf, buf2,
837                         (size_t)lengths[testnum], &aes_ks3, iv, AES_ENCRYPT);
838     return count;
839 }
840
841 static int CRYPTO_gcm128_aad_loop(void *args)
842 {
843     loopargs_t *tempargs = *(loopargs_t **) args;
844     unsigned char *buf = tempargs->buf;
845     GCM128_CONTEXT *gcm_ctx = tempargs->gcm_ctx;
846     int count;
847     for (count = 0; COND(c[D_GHASH][testnum]); count++)
848         CRYPTO_gcm128_aad(gcm_ctx, buf, lengths[testnum]);
849     return count;
850 }
851 #endif
852
853 static int RAND_bytes_loop(void *args)
854 {
855     loopargs_t *tempargs = *(loopargs_t **) args;
856     unsigned char *buf = tempargs->buf;
857     int count;
858
859     for (count = 0; COND(c[D_RAND][testnum]); count++)
860         RAND_bytes(buf, lengths[testnum]);
861     return count;
862 }
863
864 static int decrypt = 0;
865 static int EVP_Update_loop(void *args)
866 {
867     loopargs_t *tempargs = *(loopargs_t **) args;
868     unsigned char *buf = tempargs->buf;
869     EVP_CIPHER_CTX *ctx = tempargs->ctx;
870     int outl, count, rc;
871
872     if (decrypt) {
873         for (count = 0; COND(c[D_EVP][testnum]); count++) {
874             rc = EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
875             if (rc != 1) {
876                 /* reset iv in case of counter overflow */
877                 EVP_CipherInit_ex(ctx, NULL, NULL, NULL, iv, -1);
878             }
879         }
880     } else {
881         for (count = 0; COND(c[D_EVP][testnum]); count++) {
882             rc = EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
883             if (rc != 1) {
884                 /* reset iv in case of counter overflow */
885                 EVP_CipherInit_ex(ctx, NULL, NULL, NULL, iv, -1);
886             }
887         }
888     }
889     if (decrypt)
890         EVP_DecryptFinal_ex(ctx, buf, &outl);
891     else
892         EVP_EncryptFinal_ex(ctx, buf, &outl);
893     return count;
894 }
895
896 /*
897  * CCM does not support streaming. For the purpose of performance measurement,
898  * each message is encrypted using the same (key,iv)-pair. Do not use this
899  * code in your application.
900  */
901 static int EVP_Update_loop_ccm(void *args)
902 {
903     loopargs_t *tempargs = *(loopargs_t **) args;
904     unsigned char *buf = tempargs->buf;
905     EVP_CIPHER_CTX *ctx = tempargs->ctx;
906     int outl, count;
907     unsigned char tag[12];
908
909     if (decrypt) {
910         for (count = 0; COND(c[D_EVP][testnum]); count++) {
911             EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, sizeof(tag), tag);
912             /* reset iv */
913             EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, iv);
914             /* counter is reset on every update */
915             EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
916         }
917     } else {
918         for (count = 0; COND(c[D_EVP][testnum]); count++) {
919             /* restore iv length field */
920             EVP_EncryptUpdate(ctx, NULL, &outl, NULL, lengths[testnum]);
921             /* counter is reset on every update */
922             EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
923         }
924     }
925     if (decrypt)
926         EVP_DecryptFinal_ex(ctx, buf, &outl);
927     else
928         EVP_EncryptFinal_ex(ctx, buf, &outl);
929     return count;
930 }
931
932 /*
933  * To make AEAD benchmarking more relevant perform TLS-like operations,
934  * 13-byte AAD followed by payload. But don't use TLS-formatted AAD, as
935  * payload length is not actually limited by 16KB...
936  */
937 static int EVP_Update_loop_aead(void *args)
938 {
939     loopargs_t *tempargs = *(loopargs_t **) args;
940     unsigned char *buf = tempargs->buf;
941     EVP_CIPHER_CTX *ctx = tempargs->ctx;
942     int outl, count;
943     unsigned char aad[13] = { 0xcc };
944     unsigned char faketag[16] = { 0xcc };
945
946     if (decrypt) {
947         for (count = 0; COND(c[D_EVP][testnum]); count++) {
948             EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, iv);
949             EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
950                                 sizeof(faketag), faketag);
951             EVP_DecryptUpdate(ctx, NULL, &outl, aad, sizeof(aad));
952             EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
953             EVP_DecryptFinal_ex(ctx, buf + outl, &outl);
954         }
955     } else {
956         for (count = 0; COND(c[D_EVP][testnum]); count++) {
957             EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv);
958             EVP_EncryptUpdate(ctx, NULL, &outl, aad, sizeof(aad));
959             EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
960             EVP_EncryptFinal_ex(ctx, buf + outl, &outl);
961         }
962     }
963     return count;
964 }
965
966 static const EVP_MD *evp_md = NULL;
967 static int EVP_Digest_loop(void *args)
968 {
969     loopargs_t *tempargs = *(loopargs_t **) args;
970     unsigned char *buf = tempargs->buf;
971     unsigned char md[EVP_MAX_MD_SIZE];
972     int count;
973
974     for (count = 0; COND(c[D_EVP][testnum]); count++) {
975         if (!EVP_Digest(buf, lengths[testnum], md, NULL, evp_md, NULL))
976             return -1;
977     }
978     return count;
979 }
980
981 #ifndef OPENSSL_NO_DEPRECATED_3_0
982 static const EVP_MD *evp_hmac_md = NULL;
983 static char *evp_hmac_name = NULL;
984 static int EVP_HMAC_loop(void *args)
985 {
986     loopargs_t *tempargs = *(loopargs_t **) args;
987     unsigned char *buf = tempargs->buf;
988     unsigned char no_key[32];
989     int count;
990
991     for (count = 0; COND(c[D_EVP_HMAC][testnum]); count++) {
992         if (HMAC(evp_hmac_md, no_key, sizeof(no_key), buf, lengths[testnum],
993                  NULL, NULL) == NULL)
994             return -1;
995     }
996     return count;
997 }
998 #endif
999
1000 #if !defined(OPENSSL_NO_CMAC) && !defined(OPENSSL_NO_DEPRECATED_3_0)
1001 static const EVP_CIPHER *evp_cmac_cipher = NULL;
1002 static char *evp_cmac_name = NULL;
1003
1004 static int EVP_CMAC_loop(void *args)
1005 {
1006     loopargs_t *tempargs = *(loopargs_t **) args;
1007     unsigned char *buf = tempargs->buf;
1008     CMAC_CTX *cmac_ctx = tempargs->cmac_ctx;
1009     static const char key[16] = "This is a key...";
1010     unsigned char mac[16];
1011     size_t len = sizeof(mac);
1012     int count;
1013
1014     for (count = 0; COND(c[D_EVP_CMAC][testnum]); count++) {
1015         if (!CMAC_Init(cmac_ctx, key, sizeof(key), evp_cmac_cipher, NULL)
1016                 || !CMAC_Update(cmac_ctx, buf, lengths[testnum])
1017                 || !CMAC_Final(cmac_ctx, mac, &len))
1018             return -1;
1019     }
1020     return count;
1021 }
1022 #endif
1023
1024 #ifndef OPENSSL_NO_RSA
1025 static long rsa_c[RSA_NUM][2];  /* # RSA iteration test */
1026
1027 static int RSA_sign_loop(void *args)
1028 {
1029     loopargs_t *tempargs = *(loopargs_t **) args;
1030     unsigned char *buf = tempargs->buf;
1031     unsigned char *buf2 = tempargs->buf2;
1032     unsigned int *rsa_num = &tempargs->siglen;
1033     RSA **rsa_key = tempargs->rsa_key;
1034     int ret, count;
1035     for (count = 0; COND(rsa_c[testnum][0]); count++) {
1036         ret = RSA_sign(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
1037         if (ret == 0) {
1038             BIO_printf(bio_err, "RSA sign failure\n");
1039             ERR_print_errors(bio_err);
1040             count = -1;
1041             break;
1042         }
1043     }
1044     return count;
1045 }
1046
1047 static int RSA_verify_loop(void *args)
1048 {
1049     loopargs_t *tempargs = *(loopargs_t **) args;
1050     unsigned char *buf = tempargs->buf;
1051     unsigned char *buf2 = tempargs->buf2;
1052     unsigned int rsa_num = tempargs->siglen;
1053     RSA **rsa_key = tempargs->rsa_key;
1054     int ret, count;
1055     for (count = 0; COND(rsa_c[testnum][1]); count++) {
1056         ret =
1057             RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
1058         if (ret <= 0) {
1059             BIO_printf(bio_err, "RSA verify failure\n");
1060             ERR_print_errors(bio_err);
1061             count = -1;
1062             break;
1063         }
1064     }
1065     return count;
1066 }
1067 #endif
1068
1069 #ifndef OPENSSL_NO_DSA
1070 static long dsa_c[DSA_NUM][2];
1071 static int DSA_sign_loop(void *args)
1072 {
1073     loopargs_t *tempargs = *(loopargs_t **) args;
1074     unsigned char *buf = tempargs->buf;
1075     unsigned char *buf2 = tempargs->buf2;
1076     DSA **dsa_key = tempargs->dsa_key;
1077     unsigned int *siglen = &tempargs->siglen;
1078     int ret, count;
1079     for (count = 0; COND(dsa_c[testnum][0]); count++) {
1080         ret = DSA_sign(0, buf, 20, buf2, siglen, dsa_key[testnum]);
1081         if (ret == 0) {
1082             BIO_printf(bio_err, "DSA sign failure\n");
1083             ERR_print_errors(bio_err);
1084             count = -1;
1085             break;
1086         }
1087     }
1088     return count;
1089 }
1090
1091 static int DSA_verify_loop(void *args)
1092 {
1093     loopargs_t *tempargs = *(loopargs_t **) args;
1094     unsigned char *buf = tempargs->buf;
1095     unsigned char *buf2 = tempargs->buf2;
1096     DSA **dsa_key = tempargs->dsa_key;
1097     unsigned int siglen = tempargs->siglen;
1098     int ret, count;
1099     for (count = 0; COND(dsa_c[testnum][1]); count++) {
1100         ret = DSA_verify(0, buf, 20, buf2, siglen, dsa_key[testnum]);
1101         if (ret <= 0) {
1102             BIO_printf(bio_err, "DSA verify failure\n");
1103             ERR_print_errors(bio_err);
1104             count = -1;
1105             break;
1106         }
1107     }
1108     return count;
1109 }
1110 #endif
1111
1112 #ifndef OPENSSL_NO_EC
1113 static long ecdsa_c[ECDSA_NUM][2];
1114 static int ECDSA_sign_loop(void *args)
1115 {
1116     loopargs_t *tempargs = *(loopargs_t **) args;
1117     unsigned char *buf = tempargs->buf;
1118     EC_KEY **ecdsa = tempargs->ecdsa;
1119     unsigned char *ecdsasig = tempargs->buf2;
1120     unsigned int *ecdsasiglen = &tempargs->siglen;
1121     int ret, count;
1122     for (count = 0; COND(ecdsa_c[testnum][0]); count++) {
1123         ret = ECDSA_sign(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[testnum]);
1124         if (ret == 0) {
1125             BIO_printf(bio_err, "ECDSA sign failure\n");
1126             ERR_print_errors(bio_err);
1127             count = -1;
1128             break;
1129         }
1130     }
1131     return count;
1132 }
1133
1134 static int ECDSA_verify_loop(void *args)
1135 {
1136     loopargs_t *tempargs = *(loopargs_t **) args;
1137     unsigned char *buf = tempargs->buf;
1138     EC_KEY **ecdsa = tempargs->ecdsa;
1139     unsigned char *ecdsasig = tempargs->buf2;
1140     unsigned int ecdsasiglen = tempargs->siglen;
1141     int ret, count;
1142     for (count = 0; COND(ecdsa_c[testnum][1]); count++) {
1143         ret = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[testnum]);
1144         if (ret != 1) {
1145             BIO_printf(bio_err, "ECDSA verify failure\n");
1146             ERR_print_errors(bio_err);
1147             count = -1;
1148             break;
1149         }
1150     }
1151     return count;
1152 }
1153
1154 /* ******************************************************************** */
1155 static long ecdh_c[EC_NUM][1];
1156
1157 static int ECDH_EVP_derive_key_loop(void *args)
1158 {
1159     loopargs_t *tempargs = *(loopargs_t **) args;
1160     EVP_PKEY_CTX *ctx = tempargs->ecdh_ctx[testnum];
1161     unsigned char *derived_secret = tempargs->secret_a;
1162     int count;
1163     size_t *outlen = &(tempargs->outlen[testnum]);
1164
1165     for (count = 0; COND(ecdh_c[testnum][0]); count++)
1166         EVP_PKEY_derive(ctx, derived_secret, outlen);
1167
1168     return count;
1169 }
1170
1171 static long eddsa_c[EdDSA_NUM][2];
1172 static int EdDSA_sign_loop(void *args)
1173 {
1174     loopargs_t *tempargs = *(loopargs_t **) args;
1175     unsigned char *buf = tempargs->buf;
1176     EVP_MD_CTX **edctx = tempargs->eddsa_ctx;
1177     unsigned char *eddsasig = tempargs->buf2;
1178     size_t *eddsasigsize = &tempargs->sigsize;
1179     int ret, count;
1180
1181     for (count = 0; COND(eddsa_c[testnum][0]); count++) {
1182         ret = EVP_DigestSign(edctx[testnum], eddsasig, eddsasigsize, buf, 20);
1183         if (ret == 0) {
1184             BIO_printf(bio_err, "EdDSA sign failure\n");
1185             ERR_print_errors(bio_err);
1186             count = -1;
1187             break;
1188         }
1189     }
1190     return count;
1191 }
1192
1193 static int EdDSA_verify_loop(void *args)
1194 {
1195     loopargs_t *tempargs = *(loopargs_t **) args;
1196     unsigned char *buf = tempargs->buf;
1197     EVP_MD_CTX **edctx = tempargs->eddsa_ctx;
1198     unsigned char *eddsasig = tempargs->buf2;
1199     size_t eddsasigsize = tempargs->sigsize;
1200     int ret, count;
1201
1202     for (count = 0; COND(eddsa_c[testnum][1]); count++) {
1203         ret = EVP_DigestVerify(edctx[testnum], eddsasig, eddsasigsize, buf, 20);
1204         if (ret != 1) {
1205             BIO_printf(bio_err, "EdDSA verify failure\n");
1206             ERR_print_errors(bio_err);
1207             count = -1;
1208             break;
1209         }
1210     }
1211     return count;
1212 }
1213
1214 # ifndef OPENSSL_NO_SM2
1215 static long sm2_c[SM2_NUM][2];
1216 static int SM2_sign_loop(void *args)
1217 {
1218     loopargs_t *tempargs = *(loopargs_t **) args;
1219     unsigned char *buf = tempargs->buf;
1220     EVP_MD_CTX **sm2ctx = tempargs->sm2_ctx;
1221     unsigned char *sm2sig = tempargs->buf2;
1222     size_t sm2sigsize = tempargs->sigsize;
1223     const size_t max_size = tempargs->sigsize;
1224     int ret, count;
1225     EVP_PKEY **sm2_pkey = tempargs->sm2_pkey;
1226
1227     for (count = 0; COND(sm2_c[testnum][0]); count++) {
1228         if (!EVP_DigestSignInit(sm2ctx[testnum], NULL, EVP_sm3(),
1229                                 NULL, sm2_pkey[testnum])) {
1230             BIO_printf(bio_err, "SM2 init sign failure\n");
1231             ERR_print_errors(bio_err);
1232             count = -1;
1233             break;
1234         }
1235         ret = EVP_DigestSign(sm2ctx[testnum], sm2sig, &sm2sigsize,
1236                              buf, 20);
1237         if (ret == 0) {
1238             BIO_printf(bio_err, "SM2 sign failure\n");
1239             ERR_print_errors(bio_err);
1240             count = -1;
1241             break;
1242         }
1243         /* update the latest returned size and always use the fixed buffer size */
1244         tempargs->sigsize = sm2sigsize;
1245         sm2sigsize = max_size;
1246     }
1247
1248     return count;
1249 }
1250
1251 static int SM2_verify_loop(void *args)
1252 {
1253     loopargs_t *tempargs = *(loopargs_t **) args;
1254     unsigned char *buf = tempargs->buf;
1255     EVP_MD_CTX **sm2ctx = tempargs->sm2_vfy_ctx;
1256     unsigned char *sm2sig = tempargs->buf2;
1257     size_t sm2sigsize = tempargs->sigsize;
1258     int ret, count;
1259     EVP_PKEY **sm2_pkey = tempargs->sm2_pkey;
1260
1261     for (count = 0; COND(sm2_c[testnum][1]); count++) {
1262         if (!EVP_DigestVerifyInit(sm2ctx[testnum], NULL, EVP_sm3(),
1263                                   NULL, sm2_pkey[testnum])) {
1264             BIO_printf(bio_err, "SM2 verify init failure\n");
1265             ERR_print_errors(bio_err);
1266             count = -1;
1267             break;
1268         }
1269         ret = EVP_DigestVerify(sm2ctx[testnum], sm2sig, sm2sigsize,
1270                                buf, 20);
1271         if (ret != 1) {
1272             BIO_printf(bio_err, "SM2 verify failure\n");
1273             ERR_print_errors(bio_err);
1274             count = -1;
1275             break;
1276         }
1277     }
1278     return count;
1279 }
1280 # endif                         /* OPENSSL_NO_SM2 */
1281 #endif                          /* OPENSSL_NO_EC */
1282
1283 static int run_benchmark(int async_jobs,
1284                          int (*loop_function) (void *), loopargs_t * loopargs)
1285 {
1286     int job_op_count = 0;
1287     int total_op_count = 0;
1288     int num_inprogress = 0;
1289     int error = 0, i = 0, ret = 0;
1290     OSSL_ASYNC_FD job_fd = 0;
1291     size_t num_job_fds = 0;
1292
1293     if (async_jobs == 0) {
1294         return loop_function((void *)&loopargs);
1295     }
1296
1297     for (i = 0; i < async_jobs && !error; i++) {
1298         loopargs_t *looparg_item = loopargs + i;
1299
1300         /* Copy pointer content (looparg_t item address) into async context */
1301         ret = ASYNC_start_job(&loopargs[i].inprogress_job, loopargs[i].wait_ctx,
1302                               &job_op_count, loop_function,
1303                               (void *)&looparg_item, sizeof(looparg_item));
1304         switch (ret) {
1305         case ASYNC_PAUSE:
1306             ++num_inprogress;
1307             break;
1308         case ASYNC_FINISH:
1309             if (job_op_count == -1) {
1310                 error = 1;
1311             } else {
1312                 total_op_count += job_op_count;
1313             }
1314             break;
1315         case ASYNC_NO_JOBS:
1316         case ASYNC_ERR:
1317             BIO_printf(bio_err, "Failure in the job\n");
1318             ERR_print_errors(bio_err);
1319             error = 1;
1320             break;
1321         }
1322     }
1323
1324     while (num_inprogress > 0) {
1325 #if defined(OPENSSL_SYS_WINDOWS)
1326         DWORD avail = 0;
1327 #elif defined(OPENSSL_SYS_UNIX)
1328         int select_result = 0;
1329         OSSL_ASYNC_FD max_fd = 0;
1330         fd_set waitfdset;
1331
1332         FD_ZERO(&waitfdset);
1333
1334         for (i = 0; i < async_jobs && num_inprogress > 0; i++) {
1335             if (loopargs[i].inprogress_job == NULL)
1336                 continue;
1337
1338             if (!ASYNC_WAIT_CTX_get_all_fds
1339                 (loopargs[i].wait_ctx, NULL, &num_job_fds)
1340                 || num_job_fds > 1) {
1341                 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1342                 ERR_print_errors(bio_err);
1343                 error = 1;
1344                 break;
1345             }
1346             ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd,
1347                                        &num_job_fds);
1348             FD_SET(job_fd, &waitfdset);
1349             if (job_fd > max_fd)
1350                 max_fd = job_fd;
1351         }
1352
1353         if (max_fd >= (OSSL_ASYNC_FD)FD_SETSIZE) {
1354             BIO_printf(bio_err,
1355                        "Error: max_fd (%d) must be smaller than FD_SETSIZE (%d). "
1356                        "Decrease the value of async_jobs\n",
1357                        max_fd, FD_SETSIZE);
1358             ERR_print_errors(bio_err);
1359             error = 1;
1360             break;
1361         }
1362
1363         select_result = select(max_fd + 1, &waitfdset, NULL, NULL, NULL);
1364         if (select_result == -1 && errno == EINTR)
1365             continue;
1366
1367         if (select_result == -1) {
1368             BIO_printf(bio_err, "Failure in the select\n");
1369             ERR_print_errors(bio_err);
1370             error = 1;
1371             break;
1372         }
1373
1374         if (select_result == 0)
1375             continue;
1376 #endif
1377
1378         for (i = 0; i < async_jobs; i++) {
1379             if (loopargs[i].inprogress_job == NULL)
1380                 continue;
1381
1382             if (!ASYNC_WAIT_CTX_get_all_fds
1383                 (loopargs[i].wait_ctx, NULL, &num_job_fds)
1384                 || num_job_fds > 1) {
1385                 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1386                 ERR_print_errors(bio_err);
1387                 error = 1;
1388                 break;
1389             }
1390             ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd,
1391                                        &num_job_fds);
1392
1393 #if defined(OPENSSL_SYS_UNIX)
1394             if (num_job_fds == 1 && !FD_ISSET(job_fd, &waitfdset))
1395                 continue;
1396 #elif defined(OPENSSL_SYS_WINDOWS)
1397             if (num_job_fds == 1
1398                 && !PeekNamedPipe(job_fd, NULL, 0, NULL, &avail, NULL)
1399                 && avail > 0)
1400                 continue;
1401 #endif
1402
1403             ret = ASYNC_start_job(&loopargs[i].inprogress_job,
1404                                   loopargs[i].wait_ctx, &job_op_count,
1405                                   loop_function, (void *)(loopargs + i),
1406                                   sizeof(loopargs_t));
1407             switch (ret) {
1408             case ASYNC_PAUSE:
1409                 break;
1410             case ASYNC_FINISH:
1411                 if (job_op_count == -1) {
1412                     error = 1;
1413                 } else {
1414                     total_op_count += job_op_count;
1415                 }
1416                 --num_inprogress;
1417                 loopargs[i].inprogress_job = NULL;
1418                 break;
1419             case ASYNC_NO_JOBS:
1420             case ASYNC_ERR:
1421                 --num_inprogress;
1422                 loopargs[i].inprogress_job = NULL;
1423                 BIO_printf(bio_err, "Failure in the job\n");
1424                 ERR_print_errors(bio_err);
1425                 error = 1;
1426                 break;
1427             }
1428         }
1429     }
1430
1431     return error ? -1 : total_op_count;
1432 }
1433
1434 #define stop_it(do_it, test_num)\
1435     memset(do_it + test_num, 0, OSSL_NELEM(do_it) - test_num);
1436
1437 int speed_main(int argc, char **argv)
1438 {
1439     ENGINE *e = NULL;
1440     loopargs_t *loopargs = NULL;
1441     const char *prog;
1442     const char *engine_id = NULL;
1443     const EVP_CIPHER *evp_cipher = NULL;
1444     double d = 0.0;
1445     OPTION_CHOICE o;
1446     int async_init = 0, multiblock = 0, pr_header = 0;
1447     uint8_t doit[ALGOR_NUM] = { 0 };
1448     int ret = 1, misalign = 0, lengths_single = 0, aead = 0;
1449     long count = 0;
1450     unsigned int size_num = SIZE_NUM;
1451     unsigned int i, k, loopargs_len = 0, async_jobs = 0;
1452     int keylen;
1453     int buflen;
1454 #ifndef NO_FORK
1455     int multi = 0;
1456 #endif
1457 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) \
1458     || !defined(OPENSSL_NO_EC)
1459     long rsa_count = 1;
1460 #endif
1461     openssl_speed_sec_t seconds = { SECONDS, RSA_SECONDS, DSA_SECONDS,
1462                                     ECDSA_SECONDS, ECDH_SECONDS,
1463                                     EdDSA_SECONDS, SM2_SECONDS };
1464
1465     /* What follows are the buffers and key material. */
1466 #if !defined(OPENSSL_NO_RC5) && !defined(OPENSSL_NO_DEPRECATED_3_0)
1467     RC5_32_KEY rc5_ks;
1468 #endif
1469 #if !defined(OPENSSL_NO_RC2) && !defined(OPENSSL_NO_DEPRECATED_3_0)
1470     RC2_KEY rc2_ks;
1471 #endif
1472 #if !defined(OPENSSL_NO_IDEA) && !defined(OPENSSL_NO_DEPRECATED_3_0)
1473     IDEA_KEY_SCHEDULE idea_ks;
1474 #endif
1475 #if !defined(OPENSSL_NO_SEED) && !defined(OPENSSL_NO_DEPRECATED_3_0)
1476     SEED_KEY_SCHEDULE seed_ks;
1477 #endif
1478 #if !defined(OPENSSL_NO_BF) && !defined(OPENSSL_NO_DEPRECATED_3_0)
1479     BF_KEY bf_ks;
1480 #endif
1481 #if !defined(OPENSSL_NO_CAST) && !defined(OPENSSL_NO_DEPRECATED_3_0)
1482     CAST_KEY cast_ks;
1483 #endif
1484 #ifndef OPENSSL_NO_DEPRECATED_3_0
1485     static const unsigned char key16[16] = {
1486         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1487         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1488     };
1489     static const unsigned char key24[24] = {
1490         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1491         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1492         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1493     };
1494     static const unsigned char key32[32] = {
1495         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1496         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1497         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1498         0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1499     };
1500 #endif
1501 #if !defined(OPENSSL_NO_CAMELLIA) && !defined(OPENSSL_NO_DEPRECATED_3_0)
1502     CAMELLIA_KEY camellia_ks[3];
1503 #endif
1504 #ifndef OPENSSL_NO_RSA
1505     static const struct {
1506         const unsigned char *data;
1507         unsigned int length;
1508         unsigned int bits;
1509     } rsa_keys[] = {
1510         {   test512,   sizeof(test512),   512 },
1511         {  test1024,  sizeof(test1024),  1024 },
1512         {  test2048,  sizeof(test2048),  2048 },
1513         {  test3072,  sizeof(test3072),  3072 },
1514         {  test4096,  sizeof(test4096),  4092 },
1515         {  test7680,  sizeof(test7680),  7680 },
1516         { test15360, sizeof(test15360), 15360 }
1517     };
1518     uint8_t rsa_doit[RSA_NUM] = { 0 };
1519     int primes = RSA_DEFAULT_PRIME_NUM;
1520 #endif
1521 #ifndef OPENSSL_NO_DSA
1522     static const unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
1523     uint8_t dsa_doit[DSA_NUM] = { 0 };
1524 #endif
1525 #ifndef OPENSSL_NO_EC
1526     typedef struct ec_curve_st {
1527         const char *name;
1528         unsigned int nid;
1529         unsigned int bits;
1530         size_t sigsize; /* only used for EdDSA curves */
1531     } EC_CURVE;
1532     /*
1533      * We only test over the following curves as they are representative, To
1534      * add tests over more curves, simply add the curve NID and curve name to
1535      * the following arrays and increase the |ecdh_choices| and |ecdsa_choices|
1536      * lists accordingly.
1537      */
1538     static const EC_CURVE ec_curves[EC_NUM] = {
1539         /* Prime Curves */
1540         {"secp160r1", NID_secp160r1, 160},
1541         {"nistp192", NID_X9_62_prime192v1, 192},
1542         {"nistp224", NID_secp224r1, 224},
1543         {"nistp256", NID_X9_62_prime256v1, 256},
1544         {"nistp384", NID_secp384r1, 384},
1545         {"nistp521", NID_secp521r1, 521},
1546 # ifndef OPENSSL_NO_EC2M
1547         /* Binary Curves */
1548         {"nistk163", NID_sect163k1, 163},
1549         {"nistk233", NID_sect233k1, 233},
1550         {"nistk283", NID_sect283k1, 283},
1551         {"nistk409", NID_sect409k1, 409},
1552         {"nistk571", NID_sect571k1, 571},
1553         {"nistb163", NID_sect163r2, 163},
1554         {"nistb233", NID_sect233r1, 233},
1555         {"nistb283", NID_sect283r1, 283},
1556         {"nistb409", NID_sect409r1, 409},
1557         {"nistb571", NID_sect571r1, 571},
1558 # endif
1559         {"brainpoolP256r1", NID_brainpoolP256r1, 256},
1560         {"brainpoolP256t1", NID_brainpoolP256t1, 256},
1561         {"brainpoolP384r1", NID_brainpoolP384r1, 384},
1562         {"brainpoolP384t1", NID_brainpoolP384t1, 384},
1563         {"brainpoolP512r1", NID_brainpoolP512r1, 512},
1564         {"brainpoolP512t1", NID_brainpoolP512t1, 512},
1565         /* Other and ECDH only ones */
1566         {"X25519", NID_X25519, 253},
1567         {"X448", NID_X448, 448}
1568     };
1569     static const EC_CURVE ed_curves[EdDSA_NUM] = {
1570         /* EdDSA */
1571         {"Ed25519", NID_ED25519, 253, 64},
1572         {"Ed448", NID_ED448, 456, 114}
1573     };
1574 # ifndef OPENSSL_NO_SM2
1575     static const EC_CURVE sm2_curves[SM2_NUM] = {
1576         /* SM2 */
1577         {"CurveSM2", NID_sm2, 256}
1578     };
1579     uint8_t sm2_doit[SM2_NUM] = { 0 };
1580 # endif
1581     uint8_t ecdsa_doit[ECDSA_NUM] = { 0 };
1582     uint8_t ecdh_doit[EC_NUM] = { 0 };
1583     uint8_t eddsa_doit[EdDSA_NUM] = { 0 };
1584
1585     /* checks declarated curves against choices list. */
1586     OPENSSL_assert(ed_curves[EdDSA_NUM - 1].nid == NID_ED448);
1587     OPENSSL_assert(strcmp(eddsa_choices[EdDSA_NUM - 1].name, "ed448") == 0);
1588
1589     OPENSSL_assert(ec_curves[EC_NUM - 1].nid == NID_X448);
1590     OPENSSL_assert(strcmp(ecdh_choices[EC_NUM - 1].name, "ecdhx448") == 0);
1591
1592     OPENSSL_assert(ec_curves[ECDSA_NUM - 1].nid == NID_brainpoolP512t1);
1593     OPENSSL_assert(strcmp(ecdsa_choices[ECDSA_NUM - 1].name, "ecdsabrp512t1") == 0);
1594
1595 # ifndef OPENSSL_NO_SM2
1596     OPENSSL_assert(sm2_curves[SM2_NUM - 1].nid == NID_sm2);
1597     OPENSSL_assert(strcmp(sm2_choices[SM2_NUM - 1].name, "curveSM2") == 0);
1598 # endif
1599 #endif                          /* ndef OPENSSL_NO_EC */
1600
1601     prog = opt_init(argc, argv, speed_options);
1602     while ((o = opt_next()) != OPT_EOF) {
1603         switch (o) {
1604         case OPT_EOF:
1605         case OPT_ERR:
1606  opterr:
1607             BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
1608             goto end;
1609         case OPT_HELP:
1610             opt_help(speed_options);
1611             ret = 0;
1612             goto end;
1613         case OPT_ELAPSED:
1614             usertime = 0;
1615             break;
1616         case OPT_EVP:
1617             evp_md = NULL;
1618             evp_cipher = EVP_get_cipherbyname(opt_arg());
1619             if (evp_cipher == NULL)
1620                 evp_md = EVP_get_digestbyname(opt_arg());
1621             if (evp_cipher == NULL && evp_md == NULL) {
1622                 BIO_printf(bio_err,
1623                            "%s: %s is an unknown cipher or digest\n",
1624                            prog, opt_arg());
1625                 goto end;
1626             }
1627             doit[D_EVP] = 1;
1628             break;
1629         case OPT_HMAC:
1630 #ifndef OPENSSL_NO_DEPRECATED_3_0
1631             evp_hmac_md = EVP_get_digestbyname(opt_arg());
1632             if (evp_hmac_md == NULL) {
1633                 BIO_printf(bio_err, "%s: %s is an unknown digest\n",
1634                            prog, opt_arg());
1635                 goto end;
1636             }
1637             doit[D_EVP_HMAC] = 1;
1638             break;
1639 #endif
1640         case OPT_CMAC:
1641 #if !defined(OPENSSL_NO_CMAC) && !defined(OPENSSL_NO_DEPRECATED_3_0)
1642             evp_cmac_cipher = EVP_get_cipherbyname(opt_arg());
1643             if (evp_cmac_cipher == NULL) {
1644                 BIO_printf(bio_err, "%s: %s is an unknown cipher\n",
1645                            prog, opt_arg());
1646                 goto end;
1647             }
1648             doit[D_EVP_CMAC] = 1;
1649 #endif
1650             break;
1651         case OPT_DECRYPT:
1652             decrypt = 1;
1653             break;
1654         case OPT_ENGINE:
1655             /*
1656              * In a forked execution, an engine might need to be
1657              * initialised by each child process, not by the parent.
1658              * So store the name here and run setup_engine() later on.
1659              */
1660             engine_id = opt_arg();
1661             break;
1662         case OPT_MULTI:
1663 #ifndef NO_FORK
1664             multi = atoi(opt_arg());
1665 #endif
1666             break;
1667         case OPT_ASYNCJOBS:
1668 #ifndef OPENSSL_NO_ASYNC
1669             async_jobs = atoi(opt_arg());
1670             if (!ASYNC_is_capable()) {
1671                 BIO_printf(bio_err,
1672                            "%s: async_jobs specified but async not supported\n",
1673                            prog);
1674                 goto opterr;
1675             }
1676             if (async_jobs > 99999) {
1677                 BIO_printf(bio_err, "%s: too many async_jobs\n", prog);
1678                 goto opterr;
1679             }
1680 #endif
1681             break;
1682         case OPT_MISALIGN:
1683             if (!opt_int(opt_arg(), &misalign))
1684                 goto end;
1685             if (misalign > MISALIGN) {
1686                 BIO_printf(bio_err,
1687                            "%s: Maximum offset is %d\n", prog, MISALIGN);
1688                 goto opterr;
1689             }
1690             break;
1691         case OPT_MR:
1692             mr = 1;
1693             break;
1694         case OPT_MB:
1695             multiblock = 1;
1696 #ifdef OPENSSL_NO_MULTIBLOCK
1697             BIO_printf(bio_err,
1698                        "%s: -mb specified but multi-block support is disabled\n",
1699                        prog);
1700             goto end;
1701 #endif
1702             break;
1703         case OPT_R_CASES:
1704             if (!opt_rand(o))
1705                 goto end;
1706             break;
1707         case OPT_PRIMES:
1708             if (!opt_int(opt_arg(), &primes))
1709                 goto end;
1710             break;
1711         case OPT_SECONDS:
1712             seconds.sym = seconds.rsa = seconds.dsa = seconds.ecdsa
1713                         = seconds.ecdh = seconds.eddsa
1714                         = seconds.sm2 = atoi(opt_arg());
1715             break;
1716         case OPT_BYTES:
1717             lengths_single = atoi(opt_arg());
1718             lengths = &lengths_single;
1719             size_num = 1;
1720             break;
1721         case OPT_AEAD:
1722             aead = 1;
1723             break;
1724         }
1725     }
1726     argc = opt_num_rest();
1727     argv = opt_rest();
1728
1729     /* Remaining arguments are algorithms. */
1730     for (; *argv; argv++) {
1731         const char *algo = *argv;
1732
1733         if (opt_found(algo, doit_choices, &i)) {
1734             doit[i] = 1;
1735             continue;
1736         }
1737 #if !defined(OPENSSL_NO_DES) && !defined(OPENSSL_NO_DEPRECATED_3_0)
1738         if (strcmp(algo, "des") == 0) {
1739             doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
1740             continue;
1741         }
1742 #endif
1743         if (strcmp(algo, "sha") == 0) {
1744             doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
1745             continue;
1746         }
1747 #ifndef OPENSSL_NO_RSA
1748         if (strcmp(algo, "openssl") == 0) /* just for compatibility */
1749             continue;
1750         if (strncmp(algo, "rsa", 3) == 0) {
1751             if (algo[3] == '\0') {
1752                 memset(rsa_doit, 1, sizeof(rsa_doit));
1753                 continue;
1754             }
1755             if (opt_found(algo, rsa_choices, &i)) {
1756                 rsa_doit[i] = 1;
1757                 continue;
1758             }
1759         }
1760 #endif
1761 #ifndef OPENSSL_NO_DSA
1762         if (strncmp(algo, "dsa", 3) == 0) {
1763             if (algo[3] == '\0') {
1764                 memset(dsa_doit, 1, sizeof(dsa_doit));
1765                 continue;
1766             }
1767             if (opt_found(algo, dsa_choices, &i)) {
1768                 dsa_doit[i] = 2;
1769                 continue;
1770             }
1771         }
1772 #endif
1773 #ifndef OPENSSL_NO_DEPRECATED_3_0
1774         if (strcmp(algo, "aes") == 0) {
1775             doit[D_CBC_128_AES] = doit[D_CBC_192_AES] = doit[D_CBC_256_AES] = 1;
1776             continue;
1777         }
1778 #endif
1779 #if !defined(OPENSSL_NO_CAMELLIA) && !defined(OPENSSL_NO_DEPRECATED_3_0)
1780         if (strcmp(algo, "camellia") == 0) {
1781             doit[D_CBC_128_CML] = doit[D_CBC_192_CML] = doit[D_CBC_256_CML] = 1;
1782             continue;
1783         }
1784 #endif
1785 #ifndef OPENSSL_NO_EC
1786         if (strncmp(algo, "ecdsa", 5) == 0) {
1787             if (algo[5] == '\0') {
1788                 memset(ecdsa_doit, 1, sizeof(ecdsa_doit));
1789                 continue;
1790             }
1791             if (opt_found(algo, ecdsa_choices, &i)) {
1792                 ecdsa_doit[i] = 2;
1793                 continue;
1794             }
1795         }
1796         if (strncmp(algo, "ecdh", 4) == 0) {
1797             if (algo[4] == '\0') {
1798                 memset(ecdh_doit, 1, sizeof(ecdh_doit));
1799                 continue;
1800             }
1801             if (opt_found(algo, ecdh_choices, &i)) {
1802                 ecdh_doit[i] = 2;
1803                 continue;
1804             }
1805         }
1806         if (strcmp(algo, "eddsa") == 0) {
1807             memset(eddsa_doit, 1, sizeof(eddsa_doit));
1808             continue;
1809         }
1810         if (opt_found(algo, eddsa_choices, &i)) {
1811             eddsa_doit[i] = 2;
1812             continue;
1813         }
1814 # ifndef OPENSSL_NO_SM2
1815         if (strcmp(algo, "sm2") == 0) {
1816             memset(sm2_doit, 1, sizeof(sm2_doit));
1817             continue;
1818         }
1819         if (opt_found(algo, sm2_choices, &i)) {
1820             sm2_doit[i] = 2;
1821             continue;
1822         }
1823 # endif
1824 #endif  /* OPENSSL_NO_EC */
1825         BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, algo);
1826         goto end;
1827     }
1828
1829     /* Sanity checks */
1830     if (aead) {
1831         if (evp_cipher == NULL) {
1832             BIO_printf(bio_err, "-aead can be used only with an AEAD cipher\n");
1833             goto end;
1834         } else if (!(EVP_CIPHER_flags(evp_cipher) &
1835                      EVP_CIPH_FLAG_AEAD_CIPHER)) {
1836             BIO_printf(bio_err, "%s is not an AEAD cipher\n",
1837                        OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
1838             goto end;
1839         }
1840     }
1841     if (multiblock) {
1842         if (evp_cipher == NULL) {
1843             BIO_printf(bio_err,"-mb can be used only with a multi-block"
1844                                " capable cipher\n");
1845             goto end;
1846         } else if (!(EVP_CIPHER_flags(evp_cipher) &
1847                      EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
1848             BIO_printf(bio_err, "%s is not a multi-block capable\n",
1849                        OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
1850             goto end;
1851         } else if (async_jobs > 0) {
1852             BIO_printf(bio_err, "Async mode is not supported with -mb");
1853             goto end;
1854         }
1855     }
1856
1857     /* Initialize the job pool if async mode is enabled */
1858     if (async_jobs > 0) {
1859         async_init = ASYNC_init_thread(async_jobs, async_jobs);
1860         if (!async_init) {
1861             BIO_printf(bio_err, "Error creating the ASYNC job pool\n");
1862             goto end;
1863         }
1864     }
1865
1866     loopargs_len = (async_jobs == 0 ? 1 : async_jobs);
1867     loopargs =
1868         app_malloc(loopargs_len * sizeof(loopargs_t), "array of loopargs");
1869     memset(loopargs, 0, loopargs_len * sizeof(loopargs_t));
1870
1871     for (i = 0; i < loopargs_len; i++) {
1872         if (async_jobs > 0) {
1873             loopargs[i].wait_ctx = ASYNC_WAIT_CTX_new();
1874             if (loopargs[i].wait_ctx == NULL) {
1875                 BIO_printf(bio_err, "Error creating the ASYNC_WAIT_CTX\n");
1876                 goto end;
1877             }
1878         }
1879
1880         buflen = lengths[size_num - 1];
1881         if (buflen < 36)    /* size of random vector in RSA benchmark */
1882             buflen = 36;
1883         buflen += MAX_MISALIGNMENT + 1;
1884         loopargs[i].buf_malloc = app_malloc(buflen, "input buffer");
1885         loopargs[i].buf2_malloc = app_malloc(buflen, "input buffer");
1886         memset(loopargs[i].buf_malloc, 0, buflen);
1887         memset(loopargs[i].buf2_malloc, 0, buflen);
1888
1889         /* Align the start of buffers on a 64 byte boundary */
1890         loopargs[i].buf = loopargs[i].buf_malloc + misalign;
1891         loopargs[i].buf2 = loopargs[i].buf2_malloc + misalign;
1892 #ifndef OPENSSL_NO_EC
1893         loopargs[i].secret_a = app_malloc(MAX_ECDH_SIZE, "ECDH secret a");
1894         loopargs[i].secret_b = app_malloc(MAX_ECDH_SIZE, "ECDH secret b");
1895 #endif
1896     }
1897
1898 #ifndef NO_FORK
1899     if (multi && do_multi(multi, size_num))
1900         goto show_res;
1901 #endif
1902
1903     /* Initialize the engine after the fork */
1904     e = setup_engine(engine_id, 0);
1905
1906     /* No parameters; turn on everything. */
1907     if (argc == 0 && !doit[D_EVP] && !doit[D_EVP_HMAC] && !doit[D_EVP_CMAC]) {
1908         memset(doit, 1, sizeof(doit));
1909         doit[D_EVP] = doit[D_EVP_HMAC] = doit[D_EVP_CMAC] = 0;
1910 #ifndef OPENSSL_NO_RSA
1911         memset(rsa_doit, 1, sizeof(rsa_doit));
1912 #endif
1913 #ifndef OPENSSL_NO_DSA
1914         memset(dsa_doit, 1, sizeof(dsa_doit));
1915 #endif
1916 #ifndef OPENSSL_NO_EC
1917         memset(ecdsa_doit, 1, sizeof(ecdsa_doit));
1918         memset(ecdh_doit, 1, sizeof(ecdh_doit));
1919         memset(eddsa_doit, 1, sizeof(eddsa_doit));
1920 # ifndef OPENSSL_NO_SM2
1921         memset(sm2_doit, 1, sizeof(sm2_doit));
1922 # endif
1923 #endif
1924     }
1925     for (i = 0; i < ALGOR_NUM; i++)
1926         if (doit[i])
1927             pr_header++;
1928
1929     if (usertime == 0 && !mr)
1930         BIO_printf(bio_err,
1931                    "You have chosen to measure elapsed time "
1932                    "instead of user CPU time.\n");
1933
1934 #ifndef OPENSSL_NO_RSA
1935     for (i = 0; i < loopargs_len; i++) {
1936         if (primes > RSA_DEFAULT_PRIME_NUM) {
1937             /* for multi-prime RSA, skip this */
1938             break;
1939         }
1940         for (k = 0; k < RSA_NUM; k++) {
1941             const unsigned char *p = rsa_keys[k].data;
1942
1943             loopargs[i].rsa_key[k] =
1944                 d2i_RSAPrivateKey(NULL, &p, rsa_keys[k].length);
1945             if (loopargs[i].rsa_key[k] == NULL) {
1946                 BIO_printf(bio_err,
1947                            "internal error loading RSA key number %d\n", k);
1948                 goto end;
1949             }
1950         }
1951     }
1952 #endif
1953 #ifndef OPENSSL_NO_DSA
1954     for (i = 0; i < loopargs_len; i++) {
1955         loopargs[i].dsa_key[0] = get_dsa(512);
1956         loopargs[i].dsa_key[1] = get_dsa(1024);
1957         loopargs[i].dsa_key[2] = get_dsa(2048);
1958     }
1959 #endif
1960 #if !defined(OPENSSL_NO_DES) && !defined(OPENSSL_NO_DEPRECATED_3_0)
1961     if (doit[D_CBC_DES] || doit[D_EDE3_DES]) {
1962         static DES_cblock keys[] = {
1963             { 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0 }, /* keys[0] */
1964             { 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12 }, /* keys[1] */
1965             { 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34 }  /* keys[3] */
1966         };
1967         DES_set_key_unchecked(&keys[0], &sch[0]);
1968         DES_set_key_unchecked(&keys[1], &sch[1]);
1969         DES_set_key_unchecked(&keys[2], &sch[2]);
1970     }
1971 #endif
1972 #ifndef OPENSSL_NO_DEPRECATED_3_0
1973     AES_set_encrypt_key(key16, 128, &aes_ks1);
1974     AES_set_encrypt_key(key24, 192, &aes_ks2);
1975     AES_set_encrypt_key(key32, 256, &aes_ks3);
1976 #endif
1977 #if !defined(OPENSSL_NO_CAMELLIA) && !defined(OPENSSL_NO_DEPRECATED_3_0)
1978     if (doit[D_CBC_128_CML] || doit[D_CBC_192_CML] || doit[D_CBC_256_CML]) {
1979         Camellia_set_key(key16, 128, &camellia_ks[0]);
1980         Camellia_set_key(key24, 192, &camellia_ks[1]);
1981         Camellia_set_key(key32, 256, &camellia_ks[2]);
1982     }
1983 #endif
1984 #if !defined(OPENSSL_NO_IDEA) && !defined(OPENSSL_NO_DEPRECATED_3_0)
1985     if (doit[D_CBC_IDEA])
1986         IDEA_set_encrypt_key(key16, &idea_ks);
1987 #endif
1988 #if !defined(OPENSSL_NO_SEED) && !defined(OPENSSL_NO_DEPRECATED_3_0)
1989     if (doit[D_CBC_SEED])
1990         SEED_set_key(key16, &seed_ks);
1991 #endif
1992 #if !defined(OPENSSL_NO_RC4) && !defined(OPENSSL_NO_DEPRECATED_3_0)
1993     if (doit[D_RC4])
1994         RC4_set_key(&rc4_ks, 16, key16);
1995 #endif
1996 #if !defined(OPENSSL_NO_RC2) && !defined(OPENSSL_NO_DEPRECATED_3_0)
1997     if (doit[D_CBC_RC2])
1998         RC2_set_key(&rc2_ks, 16, key16, 128);
1999 #endif
2000 #if !defined(OPENSSL_NO_RC5) && !defined(OPENSSL_NO_DEPRECATED_3_0)
2001     if (doit[D_CBC_RC5])
2002         if (!RC5_32_set_key(&rc5_ks, 16, key16, 12)) {
2003             BIO_printf(bio_err, "Failed setting RC5 key\n");
2004             goto end;
2005         }
2006 #endif
2007 #if !defined(OPENSSL_NO_BF) && !defined(OPENSSL_NO_DEPRECATED_3_0)
2008     if (doit[D_CBC_BF])
2009         BF_set_key(&bf_ks, 16, key16);
2010 #endif
2011 #if !defined(OPENSSL_NO_CAST) && !defined(OPENSSL_NO_DEPRECATED_3_0)
2012     if (doit[D_CBC_CAST]) 
2013         CAST_set_key(&cast_ks, 16, key16);
2014 #endif
2015 #ifndef SIGALRM
2016 #if !defined(OPENSSL_NO_DES) && !defined(OPENSSL_NO_DEPRECATED_3_0)
2017     BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
2018     count = 10;
2019     do {
2020         long it;
2021         count *= 2;
2022         Time_F(START);
2023         for (it = count; it; it--)
2024             DES_ecb_encrypt((DES_cblock *)loopargs[0].buf,
2025                             (DES_cblock *)loopargs[0].buf, &sch, DES_ENCRYPT);
2026         d = Time_F(STOP);
2027     } while (d < 3);
2028     c[D_MD2][0] = count / 10;
2029     c[D_MDC2][0] = count / 10;
2030     c[D_MD4][0] = count;
2031     c[D_MD5][0] = count;
2032     c[D_HMAC][0] = count;
2033     c[D_SHA1][0] = count;
2034     c[D_RMD160][0] = count;
2035     c[D_RC4][0] = count * 5;
2036     c[D_CBC_DES][0] = count;
2037     c[D_EDE3_DES][0] = count / 3;
2038     c[D_CBC_IDEA][0] = count;
2039     c[D_CBC_SEED][0] = count;
2040     c[D_CBC_RC2][0] = count;
2041     c[D_CBC_RC5][0] = count;
2042     c[D_CBC_BF][0] = count;
2043     c[D_CBC_CAST][0] = count;
2044     c[D_CBC_128_AES][0] = count;
2045     c[D_CBC_192_AES][0] = count;
2046     c[D_CBC_256_AES][0] = count;
2047     c[D_CBC_128_CML][0] = count;
2048     c[D_CBC_192_CML][0] = count;
2049     c[D_CBC_256_CML][0] = count;
2050     c[D_EVP][0] = count;
2051     c[D_SHA256][0] = count;
2052     c[D_SHA512][0] = count;
2053     c[D_WHIRLPOOL][0] = count;
2054     c[D_IGE_128_AES][0] = count;
2055     c[D_IGE_192_AES][0] = count;
2056     c[D_IGE_256_AES][0] = count;
2057     c[D_GHASH][0] = count;
2058     c[D_RAND][0] = count;
2059     c[D_EVP_HMAC][0] = count;
2060     c[D_EVP_CMAC][0] = count;
2061
2062     for (i = 1; i < size_num; i++) {
2063         long l0 = (long)lengths[0];
2064         long l1 = (long)lengths[i];
2065
2066         c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
2067         c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
2068         c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
2069         c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
2070         c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
2071         c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
2072         c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
2073         c[D_EVP][i] = = c[D_EVP][0] * 4 * l0 / l1;
2074         c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
2075         c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
2076         c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
2077         c[D_GHASH][i] = c[D_GHASH][0] * 4 * l0 / l1;
2078         c[D_RAND][i] = c[D_RAND][0] * 4 * l0 / l1;
2079         c[D_EVP_HMAC][i] = = c[D_EVP_HMAC][0] * 4 * l0 / l1;
2080         c[D_EVP_CMAC][i] = = c[D_EVP_CMAC][0] * 4 * l0 / l1;
2081
2082         l0 = (long)lengths[i - 1];
2083
2084         c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
2085         c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
2086         c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
2087         c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
2088         c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
2089         c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
2090         c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
2091         c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
2092         c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
2093         c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
2094         c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
2095         c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
2096         c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
2097         c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
2098         c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
2099         c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
2100         c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
2101         c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
2102     }
2103
2104 #  ifndef OPENSSL_NO_RSA
2105     rsa_c[R_RSA_512][0] = count / 2000;
2106     rsa_c[R_RSA_512][1] = count / 400;
2107     for (i = 1; i < RSA_NUM; i++) {
2108         rsa_c[i][0] = rsa_c[i - 1][0] / 8;
2109         rsa_c[i][1] = rsa_c[i - 1][1] / 4;
2110         if (rsa_doit[i] <= 1 && rsa_c[i][0] == 0)
2111             rsa_doit[i] = 0;
2112         else {
2113             if (rsa_c[i][0] == 0) {
2114                 rsa_c[i][0] = 1; /* Set minimum iteration Nb to 1. */
2115                 rsa_c[i][1] = 20;
2116             }
2117         }
2118     }
2119 #  endif
2120
2121 #  ifndef OPENSSL_NO_DSA
2122     dsa_c[R_DSA_512][0] = count / 1000;
2123     dsa_c[R_DSA_512][1] = count / 1000 / 2;
2124     for (i = 1; i < DSA_NUM; i++) {
2125         dsa_c[i][0] = dsa_c[i - 1][0] / 4;
2126         dsa_c[i][1] = dsa_c[i - 1][1] / 4;
2127         if (dsa_doit[i] <= 1 && dsa_c[i][0] == 0)
2128             dsa_doit[i] = 0;
2129         else {
2130             if (dsa_c[i][0] == 0) {
2131                 dsa_c[i][0] = 1; /* Set minimum iteration Nb to 1. */
2132                 dsa_c[i][1] = 1;
2133             }
2134         }
2135     }
2136 #  endif
2137
2138 #  ifndef OPENSSL_NO_EC
2139     ecdsa_c[R_EC_P160][0] = count / 1000;
2140     ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
2141     for (i = R_EC_P192; i <= R_EC_P521; i++) {
2142         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
2143         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
2144         if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
2145             ecdsa_doit[i] = 0;
2146         else {
2147             if (ecdsa_c[i][0] == 0) {
2148                 ecdsa_c[i][0] = 1;
2149                 ecdsa_c[i][1] = 1;
2150             }
2151         }
2152     }
2153 #   ifndef OPENSSL_NO_EC2M
2154     ecdsa_c[R_EC_K163][0] = count / 1000;
2155     ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
2156     for (i = R_EC_K233; i <= R_EC_K571; i++) {
2157         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
2158         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
2159         if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
2160             ecdsa_doit[i] = 0;
2161         else {
2162             if (ecdsa_c[i][0] == 0) {
2163                 ecdsa_c[i][0] = 1;
2164                 ecdsa_c[i][1] = 1;
2165             }
2166         }
2167     }
2168     ecdsa_c[R_EC_B163][0] = count / 1000;
2169     ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
2170     for (i = R_EC_B233; i <= R_EC_B571; i++) {
2171         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
2172         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
2173         if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
2174             ecdsa_doit[i] = 0;
2175         else {
2176             if (ecdsa_c[i][0] == 0) {
2177                 ecdsa_c[i][0] = 1;
2178                 ecdsa_c[i][1] = 1;
2179             }
2180         }
2181     }
2182 #   endif
2183
2184     ecdh_c[R_EC_P160][0] = count / 1000;
2185     for (i = R_EC_P192; i <= R_EC_P521; i++) {
2186         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
2187         if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
2188             ecdh_doit[i] = 0;
2189         else {
2190             if (ecdh_c[i][0] == 0) {
2191                 ecdh_c[i][0] = 1;
2192             }
2193         }
2194     }
2195 #   ifndef OPENSSL_NO_EC2M
2196     ecdh_c[R_EC_K163][0] = count / 1000;
2197     for (i = R_EC_K233; i <= R_EC_K571; i++) {
2198         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
2199         if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
2200             ecdh_doit[i] = 0;
2201         else {
2202             if (ecdh_c[i][0] == 0) {
2203                 ecdh_c[i][0] = 1;
2204             }
2205         }
2206     }
2207     ecdh_c[R_EC_B163][0] = count / 1000;
2208     for (i = R_EC_B233; i <= R_EC_B571; i++) {
2209         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
2210         if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
2211             ecdh_doit[i] = 0;
2212         else {
2213             if (ecdh_c[i][0] == 0) {
2214                 ecdh_c[i][0] = 1;
2215             }
2216         }
2217     }
2218 #   endif
2219     /* repeated code good to factorize */
2220     ecdh_c[R_EC_BRP256R1][0] = count / 1000;
2221     for (i = R_EC_BRP384R1; i <= R_EC_BRP512R1; i += 2) {
2222         ecdh_c[i][0] = ecdh_c[i - 2][0] / 2;
2223         if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
2224             ecdh_doit[i] = 0;
2225         else {
2226             if (ecdh_c[i][0] == 0) {
2227                 ecdh_c[i][0] = 1;
2228             }
2229         }
2230     }
2231     ecdh_c[R_EC_BRP256T1][0] = count / 1000;
2232     for (i = R_EC_BRP384T1; i <= R_EC_BRP512T1; i += 2) {
2233         ecdh_c[i][0] = ecdh_c[i - 2][0] / 2;
2234         if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
2235             ecdh_doit[i] = 0;
2236         else {
2237             if (ecdh_c[i][0] == 0) {
2238                 ecdh_c[i][0] = 1;
2239             }
2240         }
2241     }
2242     /* default iteration count for the last two EC Curves */
2243     ecdh_c[R_EC_X25519][0] = count / 1800;
2244     ecdh_c[R_EC_X448][0] = count / 7200;
2245
2246     eddsa_c[R_EC_Ed25519][0] = count / 1800;
2247     eddsa_c[R_EC_Ed448][0] = count / 7200;
2248
2249 #   ifndef OPENSSL_NO_SM2
2250     sm2_c[R_EC_SM2P256][0] = count / 1800;
2251 #   endif
2252 #  endif                          /* OPENSSL_NO_EC */
2253
2254 # else
2255 /* not worth fixing */
2256 #  error "You cannot disable DES on systems without SIGALRM."
2257 # endif                         /* OPENSSL_NO_DES */
2258 #elif SIGALRM > 0
2259     signal(SIGALRM, alarmed);
2260 #endif                          /* SIGALRM */
2261
2262 #if !defined(OPENSSL_NO_MD2) && !defined(OPENSSL_NO_DEPRECATED_3_0)
2263     if (doit[D_MD2]) {
2264         for (testnum = 0; testnum < size_num; testnum++) {
2265             print_message(names[D_MD2], c[D_MD2][testnum], lengths[testnum],
2266                           seconds.sym);
2267             Time_F(START);
2268             count = run_benchmark(async_jobs, EVP_Digest_MD2_loop, loopargs);
2269             d = Time_F(STOP);
2270             print_result(D_MD2, testnum, count, d);
2271         }
2272     }
2273 #endif
2274 #if !defined(OPENSSL_NO_MDC2) && !defined(OPENSSL_NO_DEPRECATED_3_0)
2275     if (doit[D_MDC2]) {
2276         for (testnum = 0; testnum < size_num; testnum++) {
2277             print_message(names[D_MDC2], c[D_MDC2][testnum], lengths[testnum],
2278                           seconds.sym);
2279             Time_F(START);
2280             count = run_benchmark(async_jobs, EVP_Digest_MDC2_loop, loopargs);
2281             d = Time_F(STOP);
2282             print_result(D_MDC2, testnum, count, d);
2283             if (count < 0)
2284                 break;
2285         }
2286     }
2287 #endif
2288
2289 #if !defined(OPENSSL_NO_MD4) && !defined(OPENSSL_NO_DEPRECATED_3_0)
2290     if (doit[D_MD4]) {
2291         for (testnum = 0; testnum < size_num; testnum++) {
2292             print_message(names[D_MD4], c[D_MD4][testnum], lengths[testnum],
2293                           seconds.sym);
2294             Time_F(START);
2295             count = run_benchmark(async_jobs, EVP_Digest_MD4_loop, loopargs);
2296             d = Time_F(STOP);
2297             print_result(D_MD4, testnum, count, d);
2298             if (count < 0)
2299                 break;
2300         }
2301     }
2302 #endif
2303
2304 #if !defined(OPENSSL_NO_MD5) && !defined(OPENSSL_NO_DEPRECATED_3_0)
2305     if (doit[D_MD5]) {
2306         for (testnum = 0; testnum < size_num; testnum++) {
2307             print_message(names[D_MD5], c[D_MD5][testnum], lengths[testnum],
2308                           seconds.sym);
2309             Time_F(START);
2310             count = run_benchmark(async_jobs, MD5_loop, loopargs);
2311             d = Time_F(STOP);
2312             print_result(D_MD5, testnum, count, d);
2313         }
2314     }
2315
2316 # ifndef OPENSSL_NO_DEPRECATED_3_0
2317     if (doit[D_HMAC]) {
2318         static const char hmac_key[] = "This is a key...";
2319         int len = strlen(hmac_key);
2320
2321         for (i = 0; i < loopargs_len; i++) {
2322             loopargs[i].hctx = HMAC_CTX_new();
2323             if (loopargs[i].hctx == NULL) {
2324                 BIO_printf(bio_err, "HMAC malloc failure, exiting...");
2325                 exit(1);
2326             }
2327
2328             HMAC_Init_ex(loopargs[i].hctx, hmac_key, len, EVP_md5(), NULL);
2329         }
2330         for (testnum = 0; testnum < size_num; testnum++) {
2331             print_message(names[D_HMAC], c[D_HMAC][testnum], lengths[testnum],
2332                           seconds.sym);
2333             Time_F(START);
2334             count = run_benchmark(async_jobs, HMAC_loop, loopargs);
2335             d = Time_F(STOP);
2336             print_result(D_HMAC, testnum, count, d);
2337         }
2338         for (i = 0; i < loopargs_len; i++)
2339             HMAC_CTX_free(loopargs[i].hctx);
2340     }
2341 # endif
2342 #endif
2343 #ifndef OPENSSL_NO_DEPRECATED_3_0
2344     if (doit[D_SHA1]) {
2345         for (testnum = 0; testnum < size_num; testnum++) {
2346             print_message(names[D_SHA1], c[D_SHA1][testnum], lengths[testnum],
2347                           seconds.sym);
2348             Time_F(START);
2349             count = run_benchmark(async_jobs, SHA1_loop, loopargs);
2350             d = Time_F(STOP);
2351             print_result(D_SHA1, testnum, count, d);
2352         }
2353     }
2354     if (doit[D_SHA256]) {
2355         for (testnum = 0; testnum < size_num; testnum++) {
2356             print_message(names[D_SHA256], c[D_SHA256][testnum],
2357                           lengths[testnum], seconds.sym);
2358             Time_F(START);
2359             count = run_benchmark(async_jobs, SHA256_loop, loopargs);
2360             d = Time_F(STOP);
2361             print_result(D_SHA256, testnum, count, d);
2362         }
2363     }
2364     if (doit[D_SHA512]) {
2365         for (testnum = 0; testnum < size_num; testnum++) {
2366             print_message(names[D_SHA512], c[D_SHA512][testnum],
2367                           lengths[testnum], seconds.sym);
2368             Time_F(START);
2369             count = run_benchmark(async_jobs, SHA512_loop, loopargs);
2370             d = Time_F(STOP);
2371             print_result(D_SHA512, testnum, count, d);
2372         }
2373     }
2374 #endif
2375 #if !defined(OPENSSL_NO_WHIRLPOOL) && !defined(OPENSSL_NO_DEPRECATED_3_0)
2376     if (doit[D_WHIRLPOOL]) {
2377         for (testnum = 0; testnum < size_num; testnum++) {
2378             print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][testnum],
2379                           lengths[testnum], seconds.sym);
2380             Time_F(START);
2381             count = run_benchmark(async_jobs, WHIRLPOOL_loop, loopargs);
2382             d = Time_F(STOP);
2383             print_result(D_WHIRLPOOL, testnum, count, d);
2384         }
2385     }
2386 #endif
2387
2388 #if !defined(OPENSSL_NO_RMD160) && !defined(OPENSSL_NO_DEPRECATED_3_0)
2389     if (doit[D_RMD160]) {
2390         for (testnum = 0; testnum < size_num; testnum++) {
2391             print_message(names[D_RMD160], c[D_RMD160][testnum],
2392                           lengths[testnum], seconds.sym);
2393             Time_F(START);
2394             count = run_benchmark(async_jobs, EVP_Digest_RMD160_loop, loopargs);
2395             d = Time_F(STOP);
2396             print_result(D_RMD160, testnum, count, d);
2397             if (count < 0)
2398                 break;
2399         }
2400     }
2401 #endif
2402 #if !defined(OPENSSL_NO_RC4) && !defined(OPENSSL_NO_DEPRECATED_3_0)
2403     if (doit[D_RC4]) {
2404         for (testnum = 0; testnum < size_num; testnum++) {
2405             print_message(names[D_RC4], c[D_RC4][testnum], lengths[testnum],
2406                           seconds.sym);
2407             Time_F(START);
2408             count = run_benchmark(async_jobs, RC4_loop, loopargs);
2409             d = Time_F(STOP);
2410             print_result(D_RC4, testnum, count, d);
2411         }
2412     }
2413 #endif
2414 #if !defined(OPENSSL_NO_DES) && !defined(OPENSSL_NO_DEPRECATED_3_0)
2415     if (doit[D_CBC_DES]) {
2416         for (testnum = 0; testnum < size_num; testnum++) {
2417             print_message(names[D_CBC_DES], c[D_CBC_DES][testnum],
2418                           lengths[testnum], seconds.sym);
2419             Time_F(START);
2420             count = run_benchmark(async_jobs, DES_ncbc_encrypt_loop, loopargs);
2421             d = Time_F(STOP);
2422             print_result(D_CBC_DES, testnum, count, d);
2423         }
2424     }
2425
2426     if (doit[D_EDE3_DES]) {
2427         for (testnum = 0; testnum < size_num; testnum++) {
2428             print_message(names[D_EDE3_DES], c[D_EDE3_DES][testnum],
2429                           lengths[testnum], seconds.sym);
2430             Time_F(START);
2431             count =
2432                 run_benchmark(async_jobs, DES_ede3_cbc_encrypt_loop, loopargs);
2433             d = Time_F(STOP);
2434             print_result(D_EDE3_DES, testnum, count, d);
2435         }
2436     }
2437 #endif
2438
2439 #ifndef OPENSSL_NO_DEPRECATED_3_0
2440     if (doit[D_CBC_128_AES]) {
2441         for (testnum = 0; testnum < size_num; testnum++) {
2442             print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][testnum],
2443                           lengths[testnum], seconds.sym);
2444             Time_F(START);
2445             count =
2446                 run_benchmark(async_jobs, AES_cbc_128_encrypt_loop, loopargs);
2447             d = Time_F(STOP);
2448             print_result(D_CBC_128_AES, testnum, count, d);
2449         }
2450     }
2451     if (doit[D_CBC_192_AES]) {
2452         for (testnum = 0; testnum < size_num; testnum++) {
2453             print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][testnum],
2454                           lengths[testnum], seconds.sym);
2455             Time_F(START);
2456             count =
2457                 run_benchmark(async_jobs, AES_cbc_192_encrypt_loop, loopargs);
2458             d = Time_F(STOP);
2459             print_result(D_CBC_192_AES, testnum, count, d);
2460         }
2461     }
2462     if (doit[D_CBC_256_AES]) {
2463         for (testnum = 0; testnum < size_num; testnum++) {
2464             print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][testnum],
2465                           lengths[testnum], seconds.sym);
2466             Time_F(START);
2467             count =
2468                 run_benchmark(async_jobs, AES_cbc_256_encrypt_loop, loopargs);
2469             d = Time_F(STOP);
2470             print_result(D_CBC_256_AES, testnum, count, d);
2471         }
2472     }
2473
2474
2475     if (doit[D_IGE_128_AES]) {
2476         for (testnum = 0; testnum < size_num; testnum++) {
2477             print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][testnum],
2478                           lengths[testnum], seconds.sym);
2479             Time_F(START);
2480             count =
2481                 run_benchmark(async_jobs, AES_ige_128_encrypt_loop, loopargs);
2482             d = Time_F(STOP);
2483             print_result(D_IGE_128_AES, testnum, count, d);
2484         }
2485     }
2486     if (doit[D_IGE_192_AES]) {
2487         for (testnum = 0; testnum < size_num; testnum++) {
2488             print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][testnum],
2489                           lengths[testnum], seconds.sym);
2490             Time_F(START);
2491             count =
2492                 run_benchmark(async_jobs, AES_ige_192_encrypt_loop, loopargs);
2493             d = Time_F(STOP);
2494             print_result(D_IGE_192_AES, testnum, count, d);
2495         }
2496     }
2497     if (doit[D_IGE_256_AES]) {
2498         for (testnum = 0; testnum < size_num; testnum++) {
2499             print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][testnum],
2500                           lengths[testnum], seconds.sym);
2501             Time_F(START);
2502             count =
2503                 run_benchmark(async_jobs, AES_ige_256_encrypt_loop, loopargs);
2504             d = Time_F(STOP);
2505             print_result(D_IGE_256_AES, testnum, count, d);
2506         }
2507     }
2508     if (doit[D_GHASH]) {
2509         for (i = 0; i < loopargs_len; i++) {
2510             loopargs[i].gcm_ctx =
2511                 CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
2512             CRYPTO_gcm128_setiv(loopargs[i].gcm_ctx,
2513                                 (unsigned char *)"0123456789ab", 12);
2514         }
2515
2516         for (testnum = 0; testnum < size_num; testnum++) {
2517             print_message(names[D_GHASH], c[D_GHASH][testnum],
2518                           lengths[testnum], seconds.sym);
2519             Time_F(START);
2520             count = run_benchmark(async_jobs, CRYPTO_gcm128_aad_loop, loopargs);
2521             d = Time_F(STOP);
2522             print_result(D_GHASH, testnum, count, d);
2523         }
2524         for (i = 0; i < loopargs_len; i++)
2525             CRYPTO_gcm128_release(loopargs[i].gcm_ctx);
2526     }
2527 #endif /* OPENSSL_NO_DEPRECATED_3_0 */
2528 #if !defined(OPENSSL_NO_CAMELLIA) && !defined(OPENSSL_NO_DEPRECATED_3_0)
2529     if (doit[D_CBC_128_CML]) {
2530         if (async_jobs > 0) {
2531             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2532                        names[D_CBC_128_CML]);
2533             doit[D_CBC_128_CML] = 0;
2534         }
2535         for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2536             print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][testnum],
2537                           lengths[testnum], seconds.sym);
2538             Time_F(START);
2539             for (count = 0; COND(c[D_CBC_128_CML][testnum]); count++)
2540                 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2541                                      (size_t)lengths[testnum], &camellia_ks[0],
2542                                      iv, CAMELLIA_ENCRYPT);
2543             d = Time_F(STOP);
2544             print_result(D_CBC_128_CML, testnum, count, d);
2545         }
2546     }
2547     if (doit[D_CBC_192_CML]) {
2548         if (async_jobs > 0) {
2549             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2550                        names[D_CBC_192_CML]);
2551             doit[D_CBC_192_CML] = 0;
2552         }
2553         for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2554             print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][testnum],
2555                           lengths[testnum], seconds.sym);
2556             if (async_jobs > 0) {
2557                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2558                 exit(1);
2559             }
2560             Time_F(START);
2561             for (count = 0; COND(c[D_CBC_192_CML][testnum]); count++)
2562                 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2563                                      (size_t)lengths[testnum], &camellia_ks[1],
2564                                      iv, CAMELLIA_ENCRYPT);
2565             d = Time_F(STOP);
2566             print_result(D_CBC_192_CML, testnum, count, d);
2567         }
2568     }
2569     if (doit[D_CBC_256_CML]) {
2570         if (async_jobs > 0) {
2571             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2572                        names[D_CBC_256_CML]);
2573             doit[D_CBC_256_CML] = 0;
2574         }
2575         for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2576             print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][testnum],
2577                           lengths[testnum], seconds.sym);
2578             Time_F(START);
2579             for (count = 0; COND(c[D_CBC_256_CML][testnum]); count++)
2580                 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2581                                      (size_t)lengths[testnum], &camellia_ks[2],
2582                                      iv, CAMELLIA_ENCRYPT);
2583             d = Time_F(STOP);
2584             print_result(D_CBC_256_CML, testnum, count, d);
2585         }
2586     }
2587 #endif
2588 #if !defined(OPENSSL_NO_IDEA) && !defined(OPENSSL_NO_DEPRECATED_3_0)
2589     if (doit[D_CBC_IDEA]) {
2590         if (async_jobs > 0) {
2591             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2592                        names[D_CBC_IDEA]);
2593             doit[D_CBC_IDEA] = 0;
2594         }
2595         for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2596             print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][testnum],
2597                           lengths[testnum], seconds.sym);
2598             Time_F(START);
2599             for (count = 0; COND(c[D_CBC_IDEA][testnum]); count++)
2600                 IDEA_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2601                                  (size_t)lengths[testnum], &idea_ks,
2602                                  iv, IDEA_ENCRYPT);
2603             d = Time_F(STOP);
2604             print_result(D_CBC_IDEA, testnum, count, d);
2605         }
2606     }
2607 #endif
2608 #if !defined(OPENSSL_NO_SEED) && !defined(OPENSSL_NO_DEPRECATED_3_0)
2609     if (doit[D_CBC_SEED]) {
2610         if (async_jobs > 0) {
2611             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2612                        names[D_CBC_SEED]);
2613             doit[D_CBC_SEED] = 0;
2614         }
2615         for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2616             print_message(names[D_CBC_SEED], c[D_CBC_SEED][testnum],
2617                           lengths[testnum], seconds.sym);
2618             Time_F(START);
2619             for (count = 0; COND(c[D_CBC_SEED][testnum]); count++)
2620                 SEED_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2621                                  (size_t)lengths[testnum], &seed_ks, iv, 1);
2622             d = Time_F(STOP);
2623             print_result(D_CBC_SEED, testnum, count, d);
2624         }
2625     }
2626 #endif
2627 #if !defined(OPENSSL_NO_RC2) && !defined(OPENSSL_NO_DEPRECATED_3_0)
2628     if (doit[D_CBC_RC2]) {
2629         if (async_jobs > 0) {
2630             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2631                        names[D_CBC_RC2]);
2632             doit[D_CBC_RC2] = 0;
2633         }
2634         for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2635             print_message(names[D_CBC_RC2], c[D_CBC_RC2][testnum],
2636                           lengths[testnum], seconds.sym);
2637             if (async_jobs > 0) {
2638                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2639                 exit(1);
2640             }
2641             Time_F(START);
2642             for (count = 0; COND(c[D_CBC_RC2][testnum]); count++)
2643                 RC2_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2644                                 (size_t)lengths[testnum], &rc2_ks,
2645                                 iv, RC2_ENCRYPT);
2646             d = Time_F(STOP);
2647             print_result(D_CBC_RC2, testnum, count, d);
2648         }
2649     }
2650 #endif
2651 #if !defined(OPENSSL_NO_RC5) && !defined(OPENSSL_NO_DEPRECATED_3_0)
2652     if (doit[D_CBC_RC5]) {
2653         if (async_jobs > 0) {
2654             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2655                        names[D_CBC_RC5]);
2656             doit[D_CBC_RC5] = 0;
2657         }
2658         for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2659             print_message(names[D_CBC_RC5], c[D_CBC_RC5][testnum],
2660                           lengths[testnum], seconds.sym);
2661             if (async_jobs > 0) {
2662                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2663                 exit(1);
2664             }
2665             Time_F(START);
2666             for (count = 0; COND(c[D_CBC_RC5][testnum]); count++)
2667                 RC5_32_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2668                                    (size_t)lengths[testnum], &rc5_ks,
2669                                    iv, RC5_ENCRYPT);
2670             d = Time_F(STOP);
2671             print_result(D_CBC_RC5, testnum, count, d);
2672         }
2673     }
2674 #endif
2675 #if !defined(OPENSSL_NO_BF) && !defined(OPENSSL_NO_DEPRECATED_3_0)
2676     if (doit[D_CBC_BF]) {
2677         if (async_jobs > 0) {
2678             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2679                        names[D_CBC_BF]);
2680             doit[D_CBC_BF] = 0;
2681         }
2682         for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2683             print_message(names[D_CBC_BF], c[D_CBC_BF][testnum],
2684                           lengths[testnum], seconds.sym);
2685             Time_F(START);
2686             for (count = 0; COND(c[D_CBC_BF][testnum]); count++)
2687                 BF_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2688                                (size_t)lengths[testnum], &bf_ks,
2689                                iv, BF_ENCRYPT);
2690             d = Time_F(STOP);
2691             print_result(D_CBC_BF, testnum, count, d);
2692         }
2693     }
2694 #endif
2695 #if !defined(OPENSSL_NO_CAST) && !defined(OPENSSL_NO_DEPRECATED_3_0)
2696     if (doit[D_CBC_CAST]) {
2697         if (async_jobs > 0) {
2698             BIO_printf(bio_err, "Async mode is not supported with %s\n",
2699                        names[D_CBC_CAST]);
2700             doit[D_CBC_CAST] = 0;
2701         }
2702         for (testnum = 0; testnum < size_num && async_init == 0; testnum++) {
2703             print_message(names[D_CBC_CAST], c[D_CBC_CAST][testnum],
2704                           lengths[testnum], seconds.sym);
2705             Time_F(START);
2706             for (count = 0; COND(c[D_CBC_CAST][testnum]); count++)
2707                 CAST_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2708                                  (size_t)lengths[testnum], &cast_ks,
2709                                  iv, CAST_ENCRYPT);
2710             d = Time_F(STOP);
2711             print_result(D_CBC_CAST, testnum, count, d);
2712         }
2713     }
2714 #endif
2715     if (doit[D_RAND]) {
2716         for (testnum = 0; testnum < size_num; testnum++) {
2717             print_message(names[D_RAND], c[D_RAND][testnum], lengths[testnum],
2718                           seconds.sym);
2719             Time_F(START);
2720             count = run_benchmark(async_jobs, RAND_bytes_loop, loopargs);
2721             d = Time_F(STOP);
2722             print_result(D_RAND, testnum, count, d);
2723         }
2724     }
2725
2726     if (doit[D_EVP]) {
2727         if (evp_cipher != NULL) {
2728             int (*loopfunc) (void *) = EVP_Update_loop;
2729
2730             if (multiblock && (EVP_CIPHER_flags(evp_cipher) &
2731                                EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
2732                 multiblock_speed(evp_cipher, lengths_single, &seconds);
2733                 ret = 0;
2734                 goto end;
2735             }
2736
2737             names[D_EVP] = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
2738
2739             if (EVP_CIPHER_mode(evp_cipher) == EVP_CIPH_CCM_MODE) {
2740                 loopfunc = EVP_Update_loop_ccm;
2741             } else if (aead && (EVP_CIPHER_flags(evp_cipher) &
2742                                 EVP_CIPH_FLAG_AEAD_CIPHER)) {
2743                 loopfunc = EVP_Update_loop_aead;
2744                 if (lengths == lengths_list) {
2745                     lengths = aead_lengths_list;
2746                     size_num = OSSL_NELEM(aead_lengths_list);
2747                 }
2748             }
2749
2750             for (testnum = 0; testnum < size_num; testnum++) {
2751                 print_message(names[D_EVP], c[D_EVP][testnum], lengths[testnum],
2752                               seconds.sym);
2753
2754                 for (k = 0; k < loopargs_len; k++) {
2755                     loopargs[k].ctx = EVP_CIPHER_CTX_new();
2756                     if (loopargs[k].ctx == NULL) {
2757                         BIO_printf(bio_err, "\nEVP_CIPHER_CTX_new failure\n");
2758                         exit(1);
2759                     }
2760                     if (!EVP_CipherInit_ex(loopargs[k].ctx, evp_cipher, NULL,
2761                                            NULL, iv, decrypt ? 0 : 1)) {
2762                         BIO_printf(bio_err, "\nEVP_CipherInit_ex failure\n");
2763                         ERR_print_errors(bio_err);
2764                         exit(1);
2765                     }
2766
2767                     EVP_CIPHER_CTX_set_padding(loopargs[k].ctx, 0);
2768
2769                     keylen = EVP_CIPHER_CTX_key_length(loopargs[k].ctx);
2770                     loopargs[k].key = app_malloc(keylen, "evp_cipher key");
2771                     EVP_CIPHER_CTX_rand_key(loopargs[k].ctx, loopargs[k].key);
2772                     if (!EVP_CipherInit_ex(loopargs[k].ctx, NULL, NULL,
2773                                            loopargs[k].key, NULL, -1)) {
2774                         BIO_printf(bio_err, "\nEVP_CipherInit_ex failure\n");
2775                         ERR_print_errors(bio_err);
2776                         exit(1);
2777                     }
2778                     OPENSSL_clear_free(loopargs[k].key, keylen);
2779
2780                     /* SIV mode only allows for a single Update operation */
2781                     if (EVP_CIPHER_mode(evp_cipher) == EVP_CIPH_SIV_MODE)
2782                         EVP_CIPHER_CTX_ctrl(loopargs[k].ctx, EVP_CTRL_SET_SPEED, 1, NULL);
2783                 }
2784
2785                 Time_F(START);
2786                 count = run_benchmark(async_jobs, loopfunc, loopargs);
2787                 d = Time_F(STOP);
2788                 for (k = 0; k < loopargs_len; k++) {
2789                     EVP_CIPHER_CTX_free(loopargs[k].ctx);
2790                 }
2791                 print_result(D_EVP, testnum, count, d);
2792             }
2793         } else if (evp_md != NULL) {
2794             names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
2795
2796             for (testnum = 0; testnum < size_num; testnum++) {
2797                 print_message(names[D_EVP], c[D_EVP][testnum], lengths[testnum],
2798                               seconds.sym);
2799                 Time_F(START);
2800                 count = run_benchmark(async_jobs, EVP_Digest_loop, loopargs);
2801                 d = Time_F(STOP);
2802                 print_result(D_EVP, testnum, count, d);
2803             }
2804         }
2805     }
2806
2807 #ifndef OPENSSL_NO_DEPRECATED_3_0
2808     if (doit[D_EVP_HMAC] && evp_hmac_md != NULL) {
2809         const char *md_name = OBJ_nid2ln(EVP_MD_type(evp_hmac_md));
2810
2811         evp_hmac_name = app_malloc(sizeof("HMAC()") + strlen(md_name),
2812                                    "HMAC name");
2813         sprintf(evp_hmac_name, "HMAC(%s)", md_name);
2814         names[D_EVP_HMAC] = evp_hmac_name;
2815
2816         for (testnum = 0; testnum < size_num; testnum++) {
2817             print_message(names[D_EVP_HMAC], c[D_EVP_HMAC][testnum], lengths[testnum],
2818                           seconds.sym);
2819             Time_F(START);
2820             count = run_benchmark(async_jobs, EVP_HMAC_loop, loopargs);
2821             d = Time_F(STOP);
2822             print_result(D_EVP_HMAC, testnum, count, d);
2823         }
2824     }
2825 #endif
2826
2827 #if !defined(OPENSSL_NO_CMAC) && !defined(OPENSSL_NO_DEPRECATED_3_0)
2828     if (doit[D_EVP_CMAC] && evp_cmac_cipher != NULL) {
2829         const char *cipher_name = OBJ_nid2ln(EVP_CIPHER_type(evp_cmac_cipher));
2830
2831         evp_cmac_name = app_malloc(sizeof("CMAC()") + strlen(cipher_name),
2832                                    "CMAC name");
2833         sprintf(evp_cmac_name, "CMAC(%s)", cipher_name);
2834         names[D_EVP_CMAC] = evp_cmac_name;
2835
2836         for (i = 0; i < loopargs_len; i++) {
2837             loopargs[i].cmac_ctx = CMAC_CTX_new();
2838             if (loopargs[i].cmac_ctx == NULL) {
2839                 BIO_printf(bio_err, "CMAC malloc failure, exiting...");
2840                 exit(1);
2841             }
2842         }
2843         for (testnum = 0; testnum < size_num; testnum++) {
2844             print_message(names[D_EVP_CMAC], c[D_EVP_CMAC][testnum], lengths[testnum],
2845                           seconds.sym);
2846             Time_F(START);
2847             count = run_benchmark(async_jobs, EVP_CMAC_loop, loopargs);
2848             d = Time_F(STOP);
2849             print_result(D_EVP_CMAC, testnum, count, d);
2850         }
2851         for (i = 0; i < loopargs_len; i++)
2852             CMAC_CTX_free(loopargs[i].cmac_ctx);
2853     }
2854 #endif
2855
2856     for (i = 0; i < loopargs_len; i++)
2857         if (RAND_bytes(loopargs[i].buf, 36) <= 0)
2858             goto end;
2859
2860 #ifndef OPENSSL_NO_RSA
2861     for (testnum = 0; testnum < RSA_NUM; testnum++) {
2862         int st = 0;
2863         if (!rsa_doit[testnum])
2864             continue;
2865         for (i = 0; i < loopargs_len; i++) {
2866             if (primes > RSA_DEFAULT_PRIME_NUM) {
2867                 /* we haven't set keys yet,  generate multi-prime RSA keys */
2868                 BIGNUM *bn = BN_new();
2869
2870                 if (bn == NULL)
2871                     goto end;
2872                 if (!BN_set_word(bn, RSA_F4)) {
2873                     BN_free(bn);
2874                     goto end;
2875                 }
2876
2877                 BIO_printf(bio_err, "Generate multi-prime RSA key for %s\n",
2878                            rsa_choices[testnum].name);
2879
2880                 loopargs[i].rsa_key[testnum] = RSA_new();
2881                 if (loopargs[i].rsa_key[testnum] == NULL) {
2882                     BN_free(bn);
2883                     goto end;
2884                 }
2885
2886                 if (!RSA_generate_multi_prime_key(loopargs[i].rsa_key[testnum],
2887                                                   rsa_keys[testnum].bits,
2888                                                   primes, bn, NULL)) {
2889                     BN_free(bn);
2890                     goto end;
2891                 }
2892                 BN_free(bn);
2893             }
2894             st = RSA_sign(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2895                           &loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2896             if (st == 0)
2897                 break;
2898         }
2899         if (st == 0) {
2900             BIO_printf(bio_err,
2901                        "RSA sign failure.  No RSA sign will be done.\n");
2902             ERR_print_errors(bio_err);
2903             rsa_count = 1;
2904         } else {
2905             pkey_print_message("private", "rsa",
2906                                rsa_c[testnum][0], rsa_keys[testnum].bits,
2907                                seconds.rsa);
2908             /* RSA_blinding_on(rsa_key[testnum],NULL); */
2909             Time_F(START);
2910             count = run_benchmark(async_jobs, RSA_sign_loop, loopargs);
2911             d = Time_F(STOP);
2912             BIO_printf(bio_err,
2913                        mr ? "+R1:%ld:%d:%.2f\n"
2914                        : "%ld %u bits private RSA's in %.2fs\n",
2915                        count, rsa_keys[testnum].bits, d);
2916             rsa_results[testnum][0] = (double)count / d;
2917             rsa_count = count;
2918         }
2919
2920         for (i = 0; i < loopargs_len; i++) {
2921             st = RSA_verify(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2922                             loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2923             if (st <= 0)
2924                 break;
2925         }
2926         if (st <= 0) {
2927             BIO_printf(bio_err,
2928                        "RSA verify failure.  No RSA verify will be done.\n");
2929             ERR_print_errors(bio_err);
2930             rsa_doit[testnum] = 0;
2931         } else {
2932             pkey_print_message("public", "rsa",
2933                                rsa_c[testnum][1], rsa_keys[testnum].bits,
2934                                seconds.rsa);
2935             Time_F(START);
2936             count = run_benchmark(async_jobs, RSA_verify_loop, loopargs);
2937             d = Time_F(STOP);
2938             BIO_printf(bio_err,
2939                        mr ? "+R2:%ld:%d:%.2f\n"
2940                        : "%ld %u bits public RSA's in %.2fs\n",
2941                        count, rsa_keys[testnum].bits, d);
2942             rsa_results[testnum][1] = (double)count / d;
2943         }
2944
2945         if (rsa_count <= 1) {
2946             /* if longer than 10s, don't do any more */
2947             stop_it(rsa_doit, testnum);
2948         }
2949     }
2950 #endif                          /* OPENSSL_NO_RSA */
2951
2952     for (i = 0; i < loopargs_len; i++)
2953         if (RAND_bytes(loopargs[i].buf, 36) <= 0)
2954             goto end;
2955
2956 #ifndef OPENSSL_NO_DSA
2957     for (testnum = 0; testnum < DSA_NUM; testnum++) {
2958         int st = 0;
2959         if (!dsa_doit[testnum])
2960             continue;
2961
2962         /* DSA_generate_key(dsa_key[testnum]); */
2963         /* DSA_sign_setup(dsa_key[testnum],NULL); */
2964         for (i = 0; i < loopargs_len; i++) {
2965             st = DSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2966                           &loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2967             if (st == 0)
2968                 break;
2969         }
2970         if (st == 0) {
2971             BIO_printf(bio_err,
2972                        "DSA sign failure.  No DSA sign will be done.\n");
2973             ERR_print_errors(bio_err);
2974             rsa_count = 1;
2975         } else {
2976             pkey_print_message("sign", "dsa",
2977                                dsa_c[testnum][0], dsa_bits[testnum],
2978                                seconds.dsa);
2979             Time_F(START);
2980             count = run_benchmark(async_jobs, DSA_sign_loop, loopargs);
2981             d = Time_F(STOP);
2982             BIO_printf(bio_err,
2983                        mr ? "+R3:%ld:%u:%.2f\n"
2984                        : "%ld %u bits DSA signs in %.2fs\n",
2985                        count, dsa_bits[testnum], d);
2986             dsa_results[testnum][0] = (double)count / d;
2987             rsa_count = count;
2988         }
2989
2990         for (i = 0; i < loopargs_len; i++) {
2991             st = DSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2992                             loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2993             if (st <= 0)
2994                 break;
2995         }
2996         if (st <= 0) {
2997             BIO_printf(bio_err,
2998                        "DSA verify failure.  No DSA verify will be done.\n");
2999             ERR_print_errors(bio_err);
3000             dsa_doit[testnum] = 0;
3001         } else {
3002             pkey_print_message("verify", "dsa",
3003                                dsa_c[testnum][1], dsa_bits[testnum],
3004                                seconds.dsa);
3005             Time_F(START);
3006             count = run_benchmark(async_jobs, DSA_verify_loop, loopargs);
3007             d = Time_F(STOP);
3008             BIO_printf(bio_err,
3009                        mr ? "+R4:%ld:%u:%.2f\n"
3010                        : "%ld %u bits DSA verify in %.2fs\n",
3011                        count, dsa_bits[testnum], d);
3012             dsa_results[testnum][1] = (double)count / d;
3013         }
3014
3015         if (rsa_count <= 1) {
3016             /* if longer than 10s, don't do any more */
3017             stop_it(dsa_doit, testnum);
3018         }
3019     }
3020 #endif                          /* OPENSSL_NO_DSA */
3021
3022 #ifndef OPENSSL_NO_EC
3023     for (testnum = 0; testnum < ECDSA_NUM; testnum++) {
3024         int st = 1;
3025
3026         if (!ecdsa_doit[testnum])
3027             continue;           /* Ignore Curve */
3028         for (i = 0; i < loopargs_len; i++) {
3029             loopargs[i].ecdsa[testnum] =
3030                 EC_KEY_new_by_curve_name(ec_curves[testnum].nid);
3031             if (loopargs[i].ecdsa[testnum] == NULL) {
3032                 st = 0;
3033                 break;
3034             }
3035         }
3036         if (st == 0) {
3037             BIO_printf(bio_err, "ECDSA failure.\n");
3038             ERR_print_errors(bio_err);
3039             rsa_count = 1;
3040         } else {
3041             for (i = 0; i < loopargs_len; i++) {
3042                 EC_KEY_precompute_mult(loopargs[i].ecdsa[testnum], NULL);
3043                 /* Perform ECDSA signature test */
3044                 EC_KEY_generate_key(loopargs[i].ecdsa[testnum]);
3045                 st = ECDSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
3046                                 &loopargs[i].siglen,
3047                                 loopargs[i].ecdsa[testnum]);
3048                 if (st == 0)
3049                     break;
3050             }
3051             if (st == 0) {
3052                 BIO_printf(bio_err,
3053                            "ECDSA sign failure.  No ECDSA sign will be done.\n");
3054                 ERR_print_errors(bio_err);
3055                 rsa_count = 1;
3056             } else {
3057                 pkey_print_message("sign", "ecdsa",
3058                                    ecdsa_c[testnum][0],
3059                                    ec_curves[testnum].bits, seconds.ecdsa);
3060                 Time_F(START);
3061                 count = run_benchmark(async_jobs, ECDSA_sign_loop, loopargs);
3062                 d = Time_F(STOP);
3063
3064                 BIO_printf(bio_err,
3065                            mr ? "+R5:%ld:%u:%.2f\n" :
3066                            "%ld %u bits ECDSA signs in %.2fs \n",
3067                            count, ec_curves[testnum].bits, d);
3068                 ecdsa_results[testnum][0] = (double)count / d;
3069                 rsa_count = count;
3070             }
3071
3072             /* Perform ECDSA verification test */
3073             for (i = 0; i < loopargs_len; i++) {
3074                 st = ECDSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
3075                                   loopargs[i].siglen,
3076                                   loopargs[i].ecdsa[testnum]);
3077                 if (st != 1)
3078                     break;
3079             }
3080             if (st != 1) {
3081                 BIO_printf(bio_err,
3082                            "ECDSA verify failure.  No ECDSA verify will be done.\n");
3083                 ERR_print_errors(bio_err);
3084                 ecdsa_doit[testnum] = 0;
3085             } else {
3086                 pkey_print_message("verify", "ecdsa",
3087                                    ecdsa_c[testnum][1],
3088                                    ec_curves[testnum].bits, seconds.ecdsa);
3089                 Time_F(START);
3090                 count = run_benchmark(async_jobs, ECDSA_verify_loop, loopargs);
3091                 d = Time_F(STOP);
3092                 BIO_printf(bio_err,
3093                            mr ? "+R6:%ld:%u:%.2f\n"
3094                            : "%ld %u bits ECDSA verify in %.2fs\n",
3095                            count, ec_curves[testnum].bits, d);
3096                 ecdsa_results[testnum][1] = (double)count / d;
3097             }
3098
3099             if (rsa_count <= 1) {
3100                 /* if longer than 10s, don't do any more */
3101                 stop_it(ecdsa_doit, testnum);
3102             }
3103         }
3104     }
3105
3106     for (testnum = 0; testnum < EC_NUM; testnum++) {
3107         int ecdh_checks = 1;
3108
3109         if (!ecdh_doit[testnum])
3110             continue;
3111
3112         for (i = 0; i < loopargs_len; i++) {
3113             EVP_PKEY_CTX *kctx = NULL;
3114             EVP_PKEY_CTX *test_ctx = NULL;
3115             EVP_PKEY_CTX *ctx = NULL;
3116             EVP_PKEY *key_A = NULL;
3117             EVP_PKEY *key_B = NULL;
3118             size_t outlen;
3119             size_t test_outlen;
3120
3121             /* Ensure that the error queue is empty */
3122             if (ERR_peek_error()) {
3123                 BIO_printf(bio_err,
3124                            "WARNING: the error queue contains previous unhandled errors.\n");
3125                 ERR_print_errors(bio_err);
3126             }
3127
3128             /* Let's try to create a ctx directly from the NID: this works for
3129              * curves like Curve25519 that are not implemented through the low
3130              * level EC interface.
3131              * If this fails we try creating a EVP_PKEY_EC generic param ctx,
3132              * then we set the curve by NID before deriving the actual keygen
3133              * ctx for that specific curve. */
3134             kctx = EVP_PKEY_CTX_new_id(ec_curves[testnum].nid, NULL); /* keygen ctx from NID */
3135             if (!kctx) {
3136                 EVP_PKEY_CTX *pctx = NULL;
3137                 EVP_PKEY *params = NULL;
3138
3139                 /* If we reach this code EVP_PKEY_CTX_new_id() failed and a
3140                  * "int_ctx_new:unsupported algorithm" error was added to the
3141                  * error queue.
3142                  * We remove it from the error queue as we are handling it. */
3143                 unsigned long error = ERR_peek_error(); /* peek the latest error in the queue */
3144                 if (error == ERR_peek_last_error() && /* oldest and latest errors match */
3145                     /* check that the error origin matches */
3146                     ERR_GET_LIB(error) == ERR_LIB_EVP &&
3147                     ERR_GET_REASON(error) == EVP_R_UNSUPPORTED_ALGORITHM)
3148                     ERR_get_error(); /* pop error from queue */
3149                 if (ERR_peek_error()) {
3150                     BIO_printf(bio_err,
3151                                "Unhandled error in the error queue during ECDH init.\n");
3152                     ERR_print_errors(bio_err);
3153                     rsa_count = 1;
3154                     break;
3155                 }
3156
3157                 /* Create the context for parameter generation */
3158                 if (!(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL)) ||
3159                        /* Initialise the parameter generation */
3160                        !EVP_PKEY_paramgen_init(pctx) ||
3161                        /* Set the curve by NID */
3162                        !EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx,
3163                                                                ec_curves
3164                                                                [testnum].nid) ||
3165                        /* Create the parameter object params */
3166                        !EVP_PKEY_paramgen(pctx, &params)) {
3167                     ecdh_checks = 0;
3168                     BIO_printf(bio_err, "ECDH EC params init failure.\n");
3169                     ERR_print_errors(bio_err);
3170                     rsa_count = 1;
3171                     break;
3172                 }
3173                 /* Create the context for the key generation */
3174                 kctx = EVP_PKEY_CTX_new(params, NULL);
3175
3176                 EVP_PKEY_free(params);
3177                 params = NULL;
3178                 EVP_PKEY_CTX_free(pctx);
3179                 pctx = NULL;
3180             }
3181             if (kctx == NULL ||      /* keygen ctx is not null */
3182                 EVP_PKEY_keygen_init(kctx) <= 0/* init keygen ctx */ ) {
3183                 ecdh_checks = 0;
3184                 BIO_printf(bio_err, "ECDH keygen failure.\n");
3185                 ERR_print_errors(bio_err);
3186                 rsa_count = 1;
3187                 break;
3188             }
3189
3190             if (EVP_PKEY_keygen(kctx, &key_A) <= 0 || /* generate secret key A */
3191                 EVP_PKEY_keygen(kctx, &key_B) <= 0 || /* generate secret key B */
3192                 !(ctx = EVP_PKEY_CTX_new(key_A, NULL)) || /* derivation ctx from skeyA */
3193                 EVP_PKEY_derive_init(ctx) <= 0 || /* init derivation ctx */
3194                 EVP_PKEY_derive_set_peer(ctx, key_B) <= 0 || /* set peer pubkey in ctx */
3195                 EVP_PKEY_derive(ctx, NULL, &outlen) <= 0 || /* determine max length */
3196                 outlen == 0 ||  /* ensure outlen is a valid size */
3197                 outlen > MAX_ECDH_SIZE /* avoid buffer overflow */ ) {
3198                 ecdh_checks = 0;
3199                 BIO_printf(bio_err, "ECDH key generation failure.\n");
3200                 ERR_print_errors(bio_err);
3201                 rsa_count = 1;
3202                 break;
3203             }
3204
3205             /* Here we perform a test run, comparing the output of a*B and b*A;
3206              * we try this here and assume that further EVP_PKEY_derive calls
3207              * never fail, so we can skip checks in the actually benchmarked
3208              * code, for maximum performance. */
3209             if (!(test_ctx = EVP_PKEY_CTX_new(key_B, NULL)) || /* test ctx from skeyB */
3210                 !EVP_PKEY_derive_init(test_ctx) || /* init derivation test_ctx */
3211                 !EVP_PKEY_derive_set_peer(test_ctx, key_A) || /* set peer pubkey in test_ctx */
3212                 !EVP_PKEY_derive(test_ctx, NULL, &test_outlen) || /* determine max length */
3213                 !EVP_PKEY_derive(ctx, loopargs[i].secret_a, &outlen) || /* compute a*B */
3214                 !EVP_PKEY_derive(test_ctx, loopargs[i].secret_b, &test_outlen) || /* compute b*A */
3215                 test_outlen != outlen /* compare output length */ ) {
3216                 ecdh_checks = 0;
3217                 BIO_printf(bio_err, "ECDH computation failure.\n");
3218                 ERR_print_errors(bio_err);
3219                 rsa_count = 1;
3220                 break;
3221             }
3222
3223             /* Compare the computation results: CRYPTO_memcmp() returns 0 if equal */
3224             if (CRYPTO_memcmp(loopargs[i].secret_a,
3225                               loopargs[i].secret_b, outlen)) {
3226                 ecdh_checks = 0;
3227                 BIO_printf(bio_err, "ECDH computations don't match.\n");
3228                 ERR_print_errors(bio_err);
3229                 rsa_count = 1;
3230                 break;
3231             }
3232
3233             loopargs[i].ecdh_ctx[testnum] = ctx;
3234             loopargs[i].outlen[testnum] = outlen;
3235
3236             EVP_PKEY_free(key_A);
3237             EVP_PKEY_free(key_B);
3238             EVP_PKEY_CTX_free(kctx);
3239             kctx = NULL;
3240             EVP_PKEY_CTX_free(test_ctx);
3241             test_ctx = NULL;
3242         }
3243         if (ecdh_checks != 0) {
3244             pkey_print_message("", "ecdh",
3245                                ecdh_c[testnum][0],
3246                                ec_curves[testnum].bits, seconds.ecdh);
3247             Time_F(START);
3248             count =
3249                 run_benchmark(async_jobs, ECDH_EVP_derive_key_loop, loopargs);
3250             d = Time_F(STOP);
3251             BIO_printf(bio_err,
3252                        mr ? "+R7:%ld:%d:%.2f\n" :
3253                        "%ld %u-bits ECDH ops in %.2fs\n", count,
3254                        ec_curves[testnum].bits, d);
3255             ecdh_results[testnum][0] = (double)count / d;
3256             rsa_count = count;
3257         }
3258
3259         if (rsa_count <= 1) {
3260             /* if longer than 10s, don't do any more */
3261             stop_it(ecdh_doit, testnum);
3262         }
3263     }
3264
3265     for (testnum = 0; testnum < EdDSA_NUM; testnum++) {
3266         int st = 1;
3267         EVP_PKEY *ed_pkey = NULL;
3268         EVP_PKEY_CTX *ed_pctx = NULL;
3269
3270         if (!eddsa_doit[testnum])
3271             continue;           /* Ignore Curve */
3272         for (i = 0; i < loopargs_len; i++) {
3273             loopargs[i].eddsa_ctx[testnum] = EVP_MD_CTX_new();
3274             if (loopargs[i].eddsa_ctx[testnum] == NULL) {
3275                 st = 0;
3276                 break;
3277             }
3278
3279             if ((ed_pctx = EVP_PKEY_CTX_new_id(ed_curves[testnum].nid, NULL))
3280                     == NULL
3281                 || EVP_PKEY_keygen_init(ed_pctx) <= 0
3282                 || EVP_PKEY_keygen(ed_pctx, &ed_pkey) <= 0) {
3283                 st = 0;
3284                 EVP_PKEY_CTX_free(ed_pctx);
3285                 break;
3286             }
3287             EVP_PKEY_CTX_free(ed_pctx);
3288
3289             if (!EVP_DigestSignInit(loopargs[i].eddsa_ctx[testnum], NULL, NULL,
3290                                     NULL, ed_pkey)) {
3291                 st = 0;
3292                 EVP_PKEY_free(ed_pkey);
3293                 break;
3294             }
3295             EVP_PKEY_free(ed_pkey);
3296         }
3297         if (st == 0) {
3298             BIO_printf(bio_err, "EdDSA failure.\n");
3299             ERR_print_errors(bio_err);
3300             rsa_count = 1;
3301         } else {
3302             for (i = 0; i < loopargs_len; i++) {
3303                 /* Perform EdDSA signature test */
3304                 loopargs[i].sigsize = ed_curves[testnum].sigsize;
3305                 st = EVP_DigestSign(loopargs[i].eddsa_ctx[testnum],
3306                                     loopargs[i].buf2, &loopargs[i].sigsize,
3307                                     loopargs[i].buf, 20);
3308                 if (st == 0)
3309                     break;
3310             }
3311             if (st == 0) {
3312                 BIO_printf(bio_err,
3313                            "EdDSA sign failure.  No EdDSA sign will be done.\n");
3314                 ERR_print_errors(bio_err);
3315                 rsa_count = 1;
3316             } else {
3317                 pkey_print_message("sign", ed_curves[testnum].name,
3318                                    eddsa_c[testnum][0],
3319                                    ed_curves[testnum].bits, seconds.eddsa);
3320                 Time_F(START);
3321                 count = run_benchmark(async_jobs, EdDSA_sign_loop, loopargs);
3322                 d = Time_F(STOP);
3323
3324                 BIO_printf(bio_err,
3325                            mr ? "+R8:%ld:%u:%s:%.2f\n" :
3326                            "%ld %u bits %s signs in %.2fs \n",
3327                            count, ed_curves[testnum].bits,
3328                            ed_curves[testnum].name, d);
3329                 eddsa_results[testnum][0] = (double)count / d;
3330                 rsa_count = count;
3331             }
3332
3333             /* Perform EdDSA verification test */
3334             for (i = 0; i < loopargs_len; i++) {
3335                 st = EVP_DigestVerify(loopargs[i].eddsa_ctx[testnum],
3336                                       loopargs[i].buf2, loopargs[i].sigsize,
3337                                       loopargs[i].buf, 20);
3338                 if (st != 1)
3339                     break;
3340             }
3341             if (st != 1) {
3342                 BIO_printf(bio_err,
3343                            "EdDSA verify failure.  No EdDSA verify will be done.\n");
3344                 ERR_print_errors(bio_err);
3345                 eddsa_doit[testnum] = 0;
3346             } else {
3347                 pkey_print_message("verify", ed_curves[testnum].name,
3348                                    eddsa_c[testnum][1],
3349                                    ed_curves[testnum].bits, seconds.eddsa);
3350                 Time_F(START);
3351                 count = run_benchmark(async_jobs, EdDSA_verify_loop, loopargs);
3352                 d = Time_F(STOP);
3353                 BIO_printf(bio_err,
3354                            mr ? "+R9:%ld:%u:%s:%.2f\n"
3355                            : "%ld %u bits %s verify in %.2fs\n",
3356                            count, ed_curves[testnum].bits,
3357                            ed_curves[testnum].name, d);
3358                 eddsa_results[testnum][1] = (double)count / d;
3359             }
3360
3361             if (rsa_count <= 1) {
3362                 /* if longer than 10s, don't do any more */
3363                 stop_it(eddsa_doit, testnum);
3364             }
3365         }
3366     }
3367
3368 # ifndef OPENSSL_NO_SM2
3369     for (testnum = 0; testnum < SM2_NUM; testnum++) {
3370         int st = 1;
3371         EVP_PKEY *sm2_pkey = NULL;
3372
3373         if (!sm2_doit[testnum])
3374             continue;           /* Ignore Curve */
3375         /* Init signing and verification */
3376         for (i = 0; i < loopargs_len; i++) {
3377             EVP_PKEY_CTX *sm2_pctx = NULL;
3378             EVP_PKEY_CTX *sm2_vfy_pctx = NULL;
3379             EVP_PKEY_CTX *pctx = NULL;
3380             st = 0;
3381
3382             loopargs[i].sm2_ctx[testnum] = EVP_MD_CTX_new();
3383             loopargs[i].sm2_vfy_ctx[testnum] = EVP_MD_CTX_new();
3384             if (loopargs[i].sm2_ctx[testnum] == NULL
3385                     || loopargs[i].sm2_vfy_ctx[testnum] == NULL)
3386                 break;
3387
3388             /* SM2 keys are generated as normal EC keys with a special curve */
3389             st = !((pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL)) == NULL
3390                 || EVP_PKEY_keygen_init(pctx) <= 0
3391                 || EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx,
3392                     sm2_curves[testnum].nid) <= 0
3393                 || EVP_PKEY_keygen(pctx, &sm2_pkey) <= 0);
3394             EVP_PKEY_CTX_free(pctx);
3395             if (st == 0)
3396                 break;
3397
3398             st = 0; /* set back to zero */
3399             /* attach it sooner to rely on main final cleanup */
3400             loopargs[i].sm2_pkey[testnum] = sm2_pkey;
3401             loopargs[i].sigsize = ECDSA_size(EVP_PKEY_get0_EC_KEY(sm2_pkey));
3402
3403             sm2_pctx = EVP_PKEY_CTX_new(sm2_pkey, NULL);
3404             sm2_vfy_pctx = EVP_PKEY_CTX_new(sm2_pkey, NULL);
3405             if (sm2_pctx == NULL || sm2_vfy_pctx == NULL) {
3406                 EVP_PKEY_CTX_free(sm2_vfy_pctx);
3407                 break;
3408             }
3409             /* attach them directly to respective ctx */
3410             EVP_MD_CTX_set_pkey_ctx(loopargs[i].sm2_ctx[testnum], sm2_pctx);
3411             EVP_MD_CTX_set_pkey_ctx(loopargs[i].sm2_vfy_ctx[testnum], sm2_vfy_pctx);
3412
3413             /*
3414              * No need to allow user to set an explicit ID here, just use
3415              * the one defined in the 'draft-yang-tls-tl13-sm-suites' I-D.
3416              */
3417             if (EVP_PKEY_CTX_set1_id(sm2_pctx, SM2_ID, SM2_ID_LEN) != 1
3418                 || EVP_PKEY_CTX_set1_id(sm2_vfy_pctx, SM2_ID, SM2_ID_LEN) != 1)
3419                 break;
3420
3421             if (!EVP_DigestSignInit(loopargs[i].sm2_ctx[testnum], NULL,
3422                                     EVP_sm3(), NULL, sm2_pkey))
3423                 break;
3424             if (!EVP_DigestVerifyInit(loopargs[i].sm2_vfy_ctx[testnum], NULL,
3425                                       EVP_sm3(), NULL, sm2_pkey))
3426                 break;
3427             st = 1;         /* mark loop as succeeded */
3428         }
3429         if (st == 0) {
3430             BIO_printf(bio_err, "SM2 init failure.\n");
3431             ERR_print_errors(bio_err);
3432             rsa_count = 1;
3433         } else {
3434             for (i = 0; i < loopargs_len; i++) {
3435                 size_t sm2_sigsize = loopargs[i].sigsize;
3436
3437                 /* Perform SM2 signature test */
3438                 st = EVP_DigestSign(loopargs[i].sm2_ctx[testnum],
3439                                     loopargs[i].buf2, &sm2_sigsize,
3440                                     loopargs[i].buf, 20);
3441                 if (st == 0)
3442                     break;
3443             }
3444             if (st == 0) {
3445                 BIO_printf(bio_err,
3446                            "SM2 sign failure.  No SM2 sign will be done.\n");
3447                 ERR_print_errors(bio_err);
3448                 rsa_count = 1;
3449             } else {
3450                 pkey_print_message("sign", sm2_curves[testnum].name,
3451                                    sm2_c[testnum][0],
3452                                    sm2_curves[testnum].bits, seconds.sm2);
3453                 Time_F(START);
3454                 count = run_benchmark(async_jobs, SM2_sign_loop, loopargs);
3455                 d = Time_F(STOP);
3456
3457                 BIO_printf(bio_err,
3458                            mr ? "+R8:%ld:%u:%s:%.2f\n" :
3459                            "%ld %u bits %s signs in %.2fs \n",
3460                            count, sm2_curves[testnum].bits,
3461                            sm2_curves[testnum].name, d);
3462                 sm2_results[testnum][0] = (double)count / d;
3463                 rsa_count = count;
3464             }
3465
3466             /* Perform SM2 verification test */
3467             for (i = 0; i < loopargs_len; i++) {
3468                 st = EVP_DigestVerify(loopargs[i].sm2_vfy_ctx[testnum],
3469                                       loopargs[i].buf2, loopargs[i].sigsize,
3470                                       loopargs[i].buf, 20);
3471                 if (st != 1)
3472                     break;
3473             }
3474             if (st != 1) {
3475                 BIO_printf(bio_err,
3476                            "SM2 verify failure.  No SM2 verify will be done.\n");
3477                 ERR_print_errors(bio_err);
3478                 sm2_doit[testnum] = 0;
3479             } else {
3480                 pkey_print_message("verify", sm2_curves[testnum].name,
3481                                    sm2_c[testnum][1],
3482                                    sm2_curves[testnum].bits, seconds.sm2);
3483                 Time_F(START);
3484                 count = run_benchmark(async_jobs, SM2_verify_loop, loopargs);
3485                 d = Time_F(STOP);
3486                 BIO_printf(bio_err,
3487                            mr ? "+R9:%ld:%u:%s:%.2f\n"
3488                            : "%ld %u bits %s verify in %.2fs\n",
3489                            count, sm2_curves[testnum].bits,
3490                            sm2_curves[testnum].name, d);
3491                 sm2_results[testnum][1] = (double)count / d;
3492             }
3493
3494             if (rsa_count <= 1) {
3495                 /* if longer than 10s, don't do any more */
3496                 for (testnum++; testnum < SM2_NUM; testnum++)
3497                     sm2_doit[testnum] = 0;
3498             }
3499         }
3500     }
3501 # endif                         /* OPENSSL_NO_SM2 */
3502
3503 #endif                          /* OPENSSL_NO_EC */
3504 #ifndef NO_FORK
3505  show_res:
3506 #endif
3507     if (!mr) {
3508         printf("version: %s\n", OpenSSL_version(OPENSSL_FULL_VERSION_STRING));
3509         printf("built on: %s\n", OpenSSL_version(OPENSSL_BUILT_ON));
3510         printf("options:");
3511         printf("%s ", BN_options());
3512 #if !defined(OPENSSL_NO_MD2) && !defined(OPENSSL_NO_DEPRECATED_3_0)
3513         printf("%s ", MD2_options());
3514 #endif
3515 #if !defined(OPENSSL_NO_RC4) && !defined(OPENSSL_NO_DEPRECATED_3_0)
3516         printf("%s ", RC4_options());
3517 #endif
3518 #if !defined(OPENSSL_NO_DES) && !defined(OPENSSL_NO_DEPRECATED_3_0)
3519         printf("%s ", DES_options());
3520 #endif
3521 #ifndef OPENSSL_NO_DEPRECATED_3_0
3522         printf("%s ", AES_options());
3523 #endif
3524 #if !defined(OPENSSL_NO_IDEA) && !defined(OPENSSL_NO_DEPRECATED_3_0)
3525         printf("%s ", IDEA_options());
3526 #endif
3527 #if !defined(OPENSSL_NO_BF) && !defined(OPENSSL_NO_DEPRECATED_3_0)
3528         printf("%s ", BF_options());
3529 #endif
3530         printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
3531         printf("%s\n", OpenSSL_version(OPENSSL_CPU_INFO));
3532     }
3533
3534     if (pr_header) {
3535         if (mr)
3536             printf("+H");
3537         else {
3538             printf
3539                 ("The 'numbers' are in 1000s of bytes per second processed.\n");
3540             printf("type        ");
3541         }
3542         for (testnum = 0; testnum < size_num; testnum++)
3543             printf(mr ? ":%d" : "%7d bytes", lengths[testnum]);
3544         printf("\n");
3545     }
3546
3547     for (k = 0; k < ALGOR_NUM; k++) {
3548         if (!doit[k])
3549             continue;
3550         if (mr)
3551             printf("+F:%u:%s", k, names[k]);
3552         else
3553             printf("%-13s", names[k]);
3554         for (testnum = 0; testnum < size_num; testnum++) {
3555             if (results[k][testnum] > 10000 && !mr)
3556                 printf(" %11.2fk", results[k][testnum] / 1e3);
3557             else
3558                 printf(mr ? ":%.2f" : " %11.2f ", results[k][testnum]);
3559         }
3560         printf("\n");
3561     }
3562 #ifndef OPENSSL_NO_RSA
3563     testnum = 1;
3564     for (k = 0; k < RSA_NUM; k++) {
3565         if (!rsa_doit[k])
3566             continue;
3567         if (testnum && !mr) {
3568             printf("%18ssign    verify    sign/s verify/s\n", " ");
3569             testnum = 0;
3570         }
3571         if (mr)
3572             printf("+F2:%u:%u:%f:%f\n",
3573                    k, rsa_keys[k].bits, rsa_results[k][0], rsa_results[k][1]);
3574         else
3575             printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
3576                    rsa_keys[k].bits, 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1],
3577                    rsa_results[k][0], rsa_results[k][1]);
3578     }
3579 #endif
3580 #ifndef OPENSSL_NO_DSA
3581     testnum = 1;
3582     for (k = 0; k < DSA_NUM; k++) {
3583         if (!dsa_doit[k])
3584             continue;
3585         if (testnum && !mr) {
3586             printf("%18ssign    verify    sign/s verify/s\n", " ");
3587             testnum = 0;
3588         }
3589         if (mr)
3590             printf("+F3:%u:%u:%f:%f\n",
3591                    k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
3592         else
3593             printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
3594                    dsa_bits[k], 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1],
3595                    dsa_results[k][0], dsa_results[k][1]);
3596     }
3597 #endif
3598 #ifndef OPENSSL_NO_EC
3599     testnum = 1;
3600     for (k = 0; k < OSSL_NELEM(ecdsa_doit); k++) {
3601         if (!ecdsa_doit[k])
3602             continue;
3603         if (testnum && !mr) {
3604             printf("%30ssign    verify    sign/s verify/s\n", " ");
3605             testnum = 0;
3606         }
3607
3608         if (mr)
3609             printf("+F4:%u:%u:%f:%f\n",
3610                    k, ec_curves[k].bits,
3611                    ecdsa_results[k][0], ecdsa_results[k][1]);
3612         else
3613             printf("%4u bits ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
3614                    ec_curves[k].bits, ec_curves[k].name,
3615                    1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1],
3616                    ecdsa_results[k][0], ecdsa_results[k][1]);
3617     }
3618
3619     testnum = 1;
3620     for (k = 0; k < EC_NUM; k++) {
3621         if (!ecdh_doit[k])
3622             continue;
3623         if (testnum && !mr) {
3624             printf("%30sop      op/s\n", " ");
3625             testnum = 0;
3626         }
3627         if (mr)
3628             printf("+F5:%u:%u:%f:%f\n",
3629                    k, ec_curves[k].bits,
3630                    ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
3631
3632         else
3633             printf("%4u bits ecdh (%s) %8.4fs %8.1f\n",
3634                    ec_curves[k].bits, ec_curves[k].name,
3635                    1.0 / ecdh_results[k][0], ecdh_results[k][0]);
3636     }
3637
3638     testnum = 1;
3639     for (k = 0; k < OSSL_NELEM(eddsa_doit); k++) {
3640         if (!eddsa_doit[k])
3641             continue;
3642         if (testnum && !mr) {
3643             printf("%30ssign    verify    sign/s verify/s\n", " ");
3644             testnum = 0;
3645         }
3646
3647         if (mr)
3648             printf("+F6:%u:%u:%s:%f:%f\n",
3649                    k, ed_curves[k].bits, ed_curves[k].name,
3650                    eddsa_results[k][0], eddsa_results[k][1]);
3651         else
3652             printf("%4u bits EdDSA (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
3653                    ed_curves[k].bits, ed_curves[k].name,
3654                    1.0 / eddsa_results[k][0], 1.0 / eddsa_results[k][1],
3655                    eddsa_results[k][0], eddsa_results[k][1]);
3656     }
3657
3658 # ifndef OPENSSL_NO_SM2
3659     testnum = 1;
3660     for (k = 0; k < OSSL_NELEM(sm2_doit); k++) {
3661         if (!sm2_doit[k])
3662             continue;
3663         if (testnum && !mr) {
3664             printf("%30ssign    verify    sign/s verify/s\n", " ");
3665             testnum = 0;
3666         }
3667
3668         if (mr)
3669             printf("+F6:%u:%u:%s:%f:%f\n",
3670                    k, sm2_curves[k].bits, sm2_curves[k].name,
3671                    sm2_results[k][0], sm2_results[k][1]);
3672         else
3673             printf("%4u bits SM2 (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
3674                    sm2_curves[k].bits, sm2_curves[k].name,
3675                    1.0 / sm2_results[k][0], 1.0 / sm2_results[k][1],
3676                    sm2_results[k][0], sm2_results[k][1]);
3677     }
3678 # endif
3679 #endif                          /* OPENSSL_NO_EC */
3680
3681     ret = 0;
3682
3683  end:
3684     ERR_print_errors(bio_err);
3685     for (i = 0; i < loopargs_len; i++) {
3686         OPENSSL_free(loopargs[i].buf_malloc);
3687         OPENSSL_free(loopargs[i].buf2_malloc);
3688
3689 #ifndef OPENSSL_NO_RSA
3690         for (k = 0; k < RSA_NUM; k++)
3691             RSA_free(loopargs[i].rsa_key[k]);
3692 #endif
3693 #ifndef OPENSSL_NO_DSA
3694         for (k = 0; k < DSA_NUM; k++)
3695             DSA_free(loopargs[i].dsa_key[k]);
3696 #endif
3697 #ifndef OPENSSL_NO_EC
3698         for (k = 0; k < ECDSA_NUM; k++)
3699             EC_KEY_free(loopargs[i].ecdsa[k]);
3700         for (k = 0; k < EC_NUM; k++)
3701             EVP_PKEY_CTX_free(loopargs[i].ecdh_ctx[k]);
3702         for (k = 0; k < EdDSA_NUM; k++)
3703             EVP_MD_CTX_free(loopargs[i].eddsa_ctx[k]);
3704 # ifndef OPENSSL_NO_SM2
3705         for (k = 0; k < SM2_NUM; k++) {
3706             EVP_PKEY_CTX *pctx = NULL;
3707
3708             /* free signing ctx */
3709             if (loopargs[i].sm2_ctx[k] != NULL
3710                     && (pctx = EVP_MD_CTX_pkey_ctx(loopargs[i].sm2_ctx[k])) != NULL)
3711                 EVP_PKEY_CTX_free(pctx);
3712             EVP_MD_CTX_free(loopargs[i].sm2_ctx[k]);
3713             /* free verification ctx */
3714             if (loopargs[i].sm2_vfy_ctx[k] != NULL
3715                     && (pctx = EVP_MD_CTX_pkey_ctx(loopargs[i].sm2_vfy_ctx[k])) != NULL)
3716                 EVP_PKEY_CTX_free(pctx);
3717             EVP_MD_CTX_free(loopargs[i].sm2_vfy_ctx[k]);
3718             /* free pkey */
3719             EVP_PKEY_free(loopargs[i].sm2_pkey[k]);
3720         }
3721 # endif
3722         OPENSSL_free(loopargs[i].secret_a);
3723         OPENSSL_free(loopargs[i].secret_b);
3724 #endif
3725     }
3726 #ifndef OPENSSL_NO_DEPRECATED_3_0
3727     OPENSSL_free(evp_hmac_name);
3728 #endif
3729 #if !defined(OPENSSL_NO_CMAC) && !defined(OPENSSL_NO_DEPRECATED_3_0)
3730     OPENSSL_free(evp_cmac_name);
3731 #endif
3732
3733     if (async_jobs > 0) {
3734         for (i = 0; i < loopargs_len; i++)
3735             ASYNC_WAIT_CTX_free(loopargs[i].wait_ctx);
3736     }
3737
3738     if (async_init) {
3739         ASYNC_cleanup_thread();
3740     }
3741     OPENSSL_free(loopargs);
3742     release_engine(e);
3743     return ret;
3744 }
3745
3746 static void print_message(const char *s, long num, int length, int tm)
3747 {
3748 #ifdef SIGALRM
3749     BIO_printf(bio_err,
3750                mr ? "+DT:%s:%d:%d\n"
3751                : "Doing %s for %ds on %d size blocks: ", s, tm, length);
3752     (void)BIO_flush(bio_err);
3753     run = 1;
3754     alarm(tm);
3755 #else
3756     BIO_printf(bio_err,
3757                mr ? "+DN:%s:%ld:%d\n"
3758                : "Doing %s %ld times on %d size blocks: ", s, num, length);
3759     (void)BIO_flush(bio_err);
3760 #endif
3761 }
3762
3763 static void pkey_print_message(const char *str, const char *str2, long num,
3764                                unsigned int bits, int tm)
3765 {
3766 #ifdef SIGALRM
3767     BIO_printf(bio_err,
3768                mr ? "+DTP:%d:%s:%s:%d\n"
3769                : "Doing %u bits %s %s's for %ds: ", bits, str, str2, tm);
3770     (void)BIO_flush(bio_err);
3771     run = 1;
3772     alarm(tm);
3773 #else
3774     BIO_printf(bio_err,
3775                mr ? "+DNP:%ld:%d:%s:%s\n"
3776                : "Doing %ld %u bits %s %s's: ", num, bits, str, str2);
3777     (void)BIO_flush(bio_err);
3778 #endif
3779 }
3780
3781 static void print_result(int alg, int run_no, int count, double time_used)
3782 {
3783     if (count == -1) {
3784         BIO_printf(bio_err, "%s error!\n", names[alg]);
3785         ERR_print_errors(bio_err);
3786         /* exit(1);  disable exit until default provider enabled */
3787         return;
3788     }
3789     BIO_printf(bio_err,
3790                mr ? "+R:%d:%s:%f\n"
3791                : "%d %s's in %.2fs\n", count, names[alg], time_used);
3792     results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
3793 }
3794
3795 #ifndef NO_FORK
3796 static char *sstrsep(char **string, const char *delim)
3797 {
3798     char isdelim[256];
3799     char *token = *string;
3800
3801     if (**string == 0)
3802         return NULL;
3803
3804     memset(isdelim, 0, sizeof(isdelim));
3805     isdelim[0] = 1;
3806
3807     while (*delim) {
3808         isdelim[(unsigned char)(*delim)] = 1;
3809         delim++;
3810     }
3811
3812     while (!isdelim[(unsigned char)(**string)]) {
3813         (*string)++;
3814     }
3815
3816     if (**string) {
3817         **string = 0;
3818         (*string)++;
3819     }
3820
3821     return token;
3822 }
3823
3824 static int do_multi(int multi, int size_num)
3825 {
3826     int n;
3827     int fd[2];
3828     int *fds;
3829     static char sep[] = ":";
3830
3831     fds = app_malloc(sizeof(*fds) * multi, "fd buffer for do_multi");
3832     for (n = 0; n < multi; ++n) {
3833         if (pipe(fd) == -1) {
3834             BIO_printf(bio_err, "pipe failure\n");
3835             exit(1);
3836         }
3837         fflush(stdout);
3838         (void)BIO_flush(bio_err);
3839         if (fork()) {
3840             close(fd[1]);
3841             fds[n] = fd[0];
3842         } else {
3843             close(fd[0]);
3844             close(1);
3845             if (dup(fd[1]) == -1) {
3846                 BIO_printf(bio_err, "dup failed\n");
3847                 exit(1);
3848             }
3849             close(fd[1]);
3850             mr = 1;
3851             usertime = 0;
3852             OPENSSL_free(fds);
3853             return 0;
3854         }
3855         printf("Forked child %d\n", n);
3856     }
3857
3858     /* for now, assume the pipe is long enough to take all the output */
3859     for (n = 0; n < multi; ++n) {
3860         FILE *f;
3861         char buf[1024];
3862         char *p;
3863
3864         f = fdopen(fds[n], "r");
3865         while (fgets(buf, sizeof(buf), f)) {
3866             p = strchr(buf, '\n');
3867             if (p)
3868                 *p = '\0';
3869             if (buf[0] != '+') {
3870                 BIO_printf(bio_err,
3871                            "Don't understand line '%s' from child %d\n", buf,
3872                            n);
3873                 continue;
3874             }
3875             printf("Got: %s from %d\n", buf, n);
3876             if (strncmp(buf, "+F:", 3) == 0) {
3877                 int alg;
3878                 int j;
3879
3880                 p = buf + 3;
3881                 alg = atoi(sstrsep(&p, sep));
3882                 sstrsep(&p, sep);
3883                 for (j = 0; j < size_num; ++j)
3884                     results[alg][j] += atof(sstrsep(&p, sep));
3885             } else if (strncmp(buf, "+F2:", 4) == 0) {
3886                 int k;
3887                 double d;
3888
3889                 p = buf + 4;
3890                 k = atoi(sstrsep(&p, sep));
3891                 sstrsep(&p, sep);
3892
3893                 d = atof(sstrsep(&p, sep));
3894                 rsa_results[k][0] += d;
3895
3896                 d = atof(sstrsep(&p, sep));
3897                 rsa_results[k][1] += d;
3898             }
3899 # ifndef OPENSSL_NO_DSA
3900             else if (strncmp(buf, "+F3:", 4) == 0) {
3901                 int k;
3902                 double d;
3903
3904                 p = buf + 4;
3905                 k = atoi(sstrsep(&p, sep));
3906                 sstrsep(&p, sep);
3907
3908                 d = atof(sstrsep(&p, sep));
3909                 dsa_results[k][0] += d;
3910
3911                 d = atof(sstrsep(&p, sep));
3912                 dsa_results[k][1] += d;
3913             }
3914 # endif
3915 # ifndef OPENSSL_NO_EC
3916             else if (strncmp(buf, "+F4:", 4) == 0) {
3917                 int k;
3918                 double d;
3919
3920                 p = buf + 4;
3921                 k = atoi(sstrsep(&p, sep));
3922                 sstrsep(&p, sep);
3923
3924                 d = atof(sstrsep(&p, sep));
3925                 ecdsa_results[k][0] += d;
3926
3927                 d = atof(sstrsep(&p, sep));
3928                 ecdsa_results[k][1] += d;
3929             } else if (strncmp(buf, "+F5:", 4) == 0) {
3930                 int k;
3931                 double d;
3932
3933                 p = buf + 4;
3934                 k = atoi(sstrsep(&p, sep));
3935                 sstrsep(&p, sep);
3936
3937                 d = atof(sstrsep(&p, sep));
3938                 ecdh_results[k][0] += d;
3939             } else if (strncmp(buf, "+F6:", 4) == 0) {
3940                 int k;
3941                 double d;
3942
3943                 p = buf + 4;
3944                 k = atoi(sstrsep(&p, sep));
3945                 sstrsep(&p, sep);
3946                 sstrsep(&p, sep);
3947
3948                 d = atof(sstrsep(&p, sep));
3949                 eddsa_results[k][0] += d;
3950
3951                 d = atof(sstrsep(&p, sep));
3952                 eddsa_results[k][1] += d;
3953             }
3954 #  ifndef OPENSSL_NO_SM2
3955             else if (strncmp(buf, "+F7:", 4) == 0) {
3956                 int k;
3957                 double d;
3958
3959                 p = buf + 4;
3960                 k = atoi(sstrsep(&p, sep));
3961                 sstrsep(&p, sep);
3962
3963                 d = atof(sstrsep(&p, sep));
3964                 sm2_results[k][0] += d;
3965
3966                 d = atof(sstrsep(&p, sep));
3967                 sm2_results[k][1] += d;
3968             }
3969 #  endif /* OPENSSL_NO_SM2 */
3970 # endif
3971
3972             else if (strncmp(buf, "+H:", 3) == 0) {
3973                 ;
3974             } else
3975                 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf,
3976                            n);
3977         }
3978
3979         fclose(f);
3980     }
3981     OPENSSL_free(fds);
3982     return 1;
3983 }
3984 #endif
3985
3986 static void multiblock_speed(const EVP_CIPHER *evp_cipher, int lengths_single,
3987                              const openssl_speed_sec_t *seconds)
3988 {
3989     static const int mblengths_list[] =
3990         { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
3991     const int *mblengths = mblengths_list;
3992     int j, count, keylen, num = OSSL_NELEM(mblengths_list);
3993     const char *alg_name;
3994     unsigned char *inp, *out, *key, no_key[32], no_iv[16];
3995     EVP_CIPHER_CTX *ctx;
3996     double d = 0.0;
3997
3998     if (lengths_single) {
3999         mblengths = &lengths_single;
4000         num = 1;
4001     }
4002
4003     inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
4004     out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
4005     ctx = EVP_CIPHER_CTX_new();
4006     EVP_EncryptInit_ex(ctx, evp_cipher, NULL, NULL, no_iv);
4007
4008     keylen = EVP_CIPHER_CTX_key_length(ctx);
4009     key = app_malloc(keylen, "evp_cipher key");
4010     EVP_CIPHER_CTX_rand_key(ctx, key);
4011     EVP_EncryptInit_ex(ctx, NULL, NULL, key, NULL);
4012     OPENSSL_clear_free(key, keylen);
4013
4014     EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key), no_key);
4015     alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
4016
4017     for (j = 0; j < num; j++) {
4018         print_message(alg_name, 0, mblengths[j], seconds->sym);
4019         Time_F(START);
4020         for (count = 0; run && count < 0x7fffffff; count++) {
4021             unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
4022             EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
4023             size_t len = mblengths[j];
4024             int packlen;
4025
4026             memset(aad, 0, 8);  /* avoid uninitialized values */
4027             aad[8] = 23;        /* SSL3_RT_APPLICATION_DATA */
4028             aad[9] = 3;         /* version */
4029             aad[10] = 2;
4030             aad[11] = 0;        /* length */
4031             aad[12] = 0;
4032             mb_param.out = NULL;
4033             mb_param.inp = aad;
4034             mb_param.len = len;
4035             mb_param.interleave = 8;
4036
4037             packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
4038                                           sizeof(mb_param), &mb_param);
4039
4040             if (packlen > 0) {
4041                 mb_param.out = out;
4042                 mb_param.inp = inp;
4043                 mb_param.len = len;
4044                 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
4045                                     sizeof(mb_param), &mb_param);
4046             } else {
4047                 int pad;
4048
4049                 RAND_bytes(out, 16);
4050                 len += 16;
4051                 aad[11] = (unsigned char)(len >> 8);
4052                 aad[12] = (unsigned char)(len);
4053                 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
4054                                           EVP_AEAD_TLS1_AAD_LEN, aad);
4055                 EVP_Cipher(ctx, out, inp, len + pad);
4056             }
4057         }
4058         d = Time_F(STOP);
4059         BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
4060                    : "%d %s's in %.2fs\n", count, "evp", d);
4061         results[D_EVP][j] = ((double)count) / d * mblengths[j];
4062     }
4063
4064     if (mr) {
4065         fprintf(stdout, "+H");
4066         for (j = 0; j < num; j++)
4067             fprintf(stdout, ":%d", mblengths[j]);
4068         fprintf(stdout, "\n");
4069         fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
4070         for (j = 0; j < num; j++)
4071             fprintf(stdout, ":%.2f", results[D_EVP][j]);
4072         fprintf(stdout, "\n");
4073     } else {
4074         fprintf(stdout,
4075                 "The 'numbers' are in 1000s of bytes per second processed.\n");
4076         fprintf(stdout, "type                    ");
4077         for (j = 0; j < num; j++)
4078             fprintf(stdout, "%7d bytes", mblengths[j]);
4079         fprintf(stdout, "\n");
4080         fprintf(stdout, "%-24s", alg_name);
4081
4082         for (j = 0; j < num; j++) {
4083             if (results[D_EVP][j] > 10000)
4084                 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
4085             else
4086                 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
4087         }
4088         fprintf(stdout, "\n");
4089     }
4090
4091     OPENSSL_free(inp);
4092     OPENSSL_free(out);
4093     EVP_CIPHER_CTX_free(ctx);
4094 }