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